SimulateCustomPolicyRequest.h

 
#pragma once
#include <aws/iam/IAM_EXPORTS.h>
#include <aws/iam/IAMRequest.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/iam/model/ContextEntry.h>
#include <utility>
 
namespace Aws
{
namespace IAM
{
namespace Model
{
 
  class SimulateCustomPolicyRequest : public IAMRequest
  {
  public:
    AWS_IAM_API SimulateCustomPolicyRequest() = default;
 
    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "SimulateCustomPolicy"; }
 
    AWS_IAM_API Aws::String SerializePayload() const override;
 
  protected:
    AWS_IAM_API void DumpBodyToUrl(Aws::Http::URI& uri ) const override;
 
  public:
 
 
    inline const Aws::Vector<Aws::String>& GetPolicyInputList() const { return m_policyInputList; }
    inline bool PolicyInputListHasBeenSet() const { return m_policyInputListHasBeenSet; }
    template<typename PolicyInputListT = Aws::Vector<Aws::String>>
    void SetPolicyInputList(PolicyInputListT&& value) { m_policyInputListHasBeenSet = true; m_policyInputList = std::forward<PolicyInputListT>(value); }
    template<typename PolicyInputListT = Aws::Vector<Aws::String>>
    SimulateCustomPolicyRequest& WithPolicyInputList(PolicyInputListT&& value) { SetPolicyInputList(std::forward<PolicyInputListT>(value)); return *this;}
    template<typename PolicyInputListT = Aws::String>
    SimulateCustomPolicyRequest& AddPolicyInputList(PolicyInputListT&& value) { m_policyInputListHasBeenSet = true; m_policyInputList.emplace_back(std::forward<PolicyInputListT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetPermissionsBoundaryPolicyInputList() const { return m_permissionsBoundaryPolicyInputList; }
    inline bool PermissionsBoundaryPolicyInputListHasBeenSet() const { return m_permissionsBoundaryPolicyInputListHasBeenSet; }
    template<typename PermissionsBoundaryPolicyInputListT = Aws::Vector<Aws::String>>
    void SetPermissionsBoundaryPolicyInputList(PermissionsBoundaryPolicyInputListT&& value) { m_permissionsBoundaryPolicyInputListHasBeenSet = true; m_permissionsBoundaryPolicyInputList = std::forward<PermissionsBoundaryPolicyInputListT>(value); }
    template<typename PermissionsBoundaryPolicyInputListT = Aws::Vector<Aws::String>>
    SimulateCustomPolicyRequest& WithPermissionsBoundaryPolicyInputList(PermissionsBoundaryPolicyInputListT&& value) { SetPermissionsBoundaryPolicyInputList(std::forward<PermissionsBoundaryPolicyInputListT>(value)); return *this;}
    template<typename PermissionsBoundaryPolicyInputListT = Aws::String>
    SimulateCustomPolicyRequest& AddPermissionsBoundaryPolicyInputList(PermissionsBoundaryPolicyInputListT&& value) { m_permissionsBoundaryPolicyInputListHasBeenSet = true; m_permissionsBoundaryPolicyInputList.emplace_back(std::forward<PermissionsBoundaryPolicyInputListT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetActionNames() const { return m_actionNames; }
    inline bool ActionNamesHasBeenSet() const { return m_actionNamesHasBeenSet; }
    template<typename ActionNamesT = Aws::Vector<Aws::String>>
    void SetActionNames(ActionNamesT&& value) { m_actionNamesHasBeenSet = true; m_actionNames = std::forward<ActionNamesT>(value); }
    template<typename ActionNamesT = Aws::Vector<Aws::String>>
    SimulateCustomPolicyRequest& WithActionNames(ActionNamesT&& value) { SetActionNames(std::forward<ActionNamesT>(value)); return *this;}
    template<typename ActionNamesT = Aws::String>
    SimulateCustomPolicyRequest& AddActionNames(ActionNamesT&& value) { m_actionNamesHasBeenSet = true; m_actionNames.emplace_back(std::forward<ActionNamesT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetResourceArns() const { return m_resourceArns; }
    inline bool ResourceArnsHasBeenSet() const { return m_resourceArnsHasBeenSet; }
    template<typename ResourceArnsT = Aws::Vector<Aws::String>>
    void SetResourceArns(ResourceArnsT&& value) { m_resourceArnsHasBeenSet = true; m_resourceArns = std::forward<ResourceArnsT>(value); }
    template<typename ResourceArnsT = Aws::Vector<Aws::String>>
    SimulateCustomPolicyRequest& WithResourceArns(ResourceArnsT&& value) { SetResourceArns(std::forward<ResourceArnsT>(value)); return *this;}
    template<typename ResourceArnsT = Aws::String>
    SimulateCustomPolicyRequest& AddResourceArns(ResourceArnsT&& value) { m_resourceArnsHasBeenSet = true; m_resourceArns.emplace_back(std::forward<ResourceArnsT>(value)); return *this; }
 
 
    inline const Aws::String& GetResourcePolicy() const { return m_resourcePolicy; }
    inline bool ResourcePolicyHasBeenSet() const { return m_resourcePolicyHasBeenSet; }
    template<typename ResourcePolicyT = Aws::String>
    void SetResourcePolicy(ResourcePolicyT&& value) { m_resourcePolicyHasBeenSet = true; m_resourcePolicy = std::forward<ResourcePolicyT>(value); }
    template<typename ResourcePolicyT = Aws::String>
    SimulateCustomPolicyRequest& WithResourcePolicy(ResourcePolicyT&& value) { SetResourcePolicy(std::forward<ResourcePolicyT>(value)); return *this;}
 
 
    inline const Aws::String& GetResourceOwner() const { return m_resourceOwner; }
    inline bool ResourceOwnerHasBeenSet() const { return m_resourceOwnerHasBeenSet; }
    template<typename ResourceOwnerT = Aws::String>
    void SetResourceOwner(ResourceOwnerT&& value) { m_resourceOwnerHasBeenSet = true; m_resourceOwner = std::forward<ResourceOwnerT>(value); }
    template<typename ResourceOwnerT = Aws::String>
    SimulateCustomPolicyRequest& WithResourceOwner(ResourceOwnerT&& value) { SetResourceOwner(std::forward<ResourceOwnerT>(value)); return *this;}
 
 
    inline const Aws::String& GetCallerArn() const { return m_callerArn; }
    inline bool CallerArnHasBeenSet() const { return m_callerArnHasBeenSet; }
    template<typename CallerArnT = Aws::String>
    void SetCallerArn(CallerArnT&& value) { m_callerArnHasBeenSet = true; m_callerArn = std::forward<CallerArnT>(value); }
    template<typename CallerArnT = Aws::String>
    SimulateCustomPolicyRequest& WithCallerArn(CallerArnT&& value) { SetCallerArn(std::forward<CallerArnT>(value)); return *this;}
 
 
    inline const Aws::Vector<ContextEntry>& GetContextEntries() const { return m_contextEntries; }
    inline bool ContextEntriesHasBeenSet() const { return m_contextEntriesHasBeenSet; }
    template<typename ContextEntriesT = Aws::Vector<ContextEntry>>
    void SetContextEntries(ContextEntriesT&& value) { m_contextEntriesHasBeenSet = true; m_contextEntries = std::forward<ContextEntriesT>(value); }
    template<typename ContextEntriesT = Aws::Vector<ContextEntry>>
    SimulateCustomPolicyRequest& WithContextEntries(ContextEntriesT&& value) { SetContextEntries(std::forward<ContextEntriesT>(value)); return *this;}
    template<typename ContextEntriesT = ContextEntry>
    SimulateCustomPolicyRequest& AddContextEntries(ContextEntriesT&& value) { m_contextEntriesHasBeenSet = true; m_contextEntries.emplace_back(std::forward<ContextEntriesT>(value)); return *this; }
 
 
    inline const Aws::String& GetResourceHandlingOption() const { return m_resourceHandlingOption; }
    inline bool ResourceHandlingOptionHasBeenSet() const { return m_resourceHandlingOptionHasBeenSet; }
    template<typename ResourceHandlingOptionT = Aws::String>
    void SetResourceHandlingOption(ResourceHandlingOptionT&& value) { m_resourceHandlingOptionHasBeenSet = true; m_resourceHandlingOption = std::forward<ResourceHandlingOptionT>(value); }
    template<typename ResourceHandlingOptionT = Aws::String>
    SimulateCustomPolicyRequest& WithResourceHandlingOption(ResourceHandlingOptionT&& value) { SetResourceHandlingOption(std::forward<ResourceHandlingOptionT>(value)); return *this;}
 
 
    inline int GetMaxItems() const { return m_maxItems; }
    inline bool MaxItemsHasBeenSet() const { return m_maxItemsHasBeenSet; }
    inline void SetMaxItems(int value) { m_maxItemsHasBeenSet = true; m_maxItems = value; }
    inline SimulateCustomPolicyRequest& WithMaxItems(int value) { SetMaxItems(value); return *this;}
 
 
    inline const Aws::String& GetMarker() const { return m_marker; }
    inline bool MarkerHasBeenSet() const { return m_markerHasBeenSet; }
    template<typename MarkerT = Aws::String>
    void SetMarker(MarkerT&& value) { m_markerHasBeenSet = true; m_marker = std::forward<MarkerT>(value); }
    template<typename MarkerT = Aws::String>
    SimulateCustomPolicyRequest& WithMarker(MarkerT&& value) { SetMarker(std::forward<MarkerT>(value)); return *this;}
  private:
 
    Aws::Vector<Aws::String> m_policyInputList;
    bool m_policyInputListHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_permissionsBoundaryPolicyInputList;
    bool m_permissionsBoundaryPolicyInputListHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_actionNames;
    bool m_actionNamesHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_resourceArns;
    bool m_resourceArnsHasBeenSet = false;
 
    Aws::String m_resourcePolicy;
    bool m_resourcePolicyHasBeenSet = false;
 
    Aws::String m_resourceOwner;
    bool m_resourceOwnerHasBeenSet = false;
 
    Aws::String m_callerArn;
    bool m_callerArnHasBeenSet = false;
 
    Aws::Vector<ContextEntry> m_contextEntries;
    bool m_contextEntriesHasBeenSet = false;
 
    Aws::String m_resourceHandlingOption;
    bool m_resourceHandlingOptionHasBeenSet = false;
 
    int m_maxItems{0};
    bool m_maxItemsHasBeenSet = false;
 
    Aws::String m_marker;
    bool m_markerHasBeenSet = false;
  };
 
} // namespace Model
} // namespace IAM
} // namespace Aws