SimulatePrincipalPolicyRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/iam/IAMRequest.h>
#include <aws/iam/IAM_EXPORTS.h>
#include <aws/iam/model/ContextEntry.h>
#include <aws/iam/model/PolicyIdentifier.h>
 
#include <utility>
 
namespace Aws {
namespace IAM {
namespace Model {
 
class SimulatePrincipalPolicyRequest : public IAMRequest {
 public:
  AWS_IAM_API SimulatePrincipalPolicyRequest() = 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 "SimulatePrincipalPolicy"; }
 
  AWS_IAM_API Aws::String SerializePayload() const override;
 
 protected:
  AWS_IAM_API void DumpBodyToUrl(Aws::Http::URI& uri) const override;
 
 public:
 
  inline const Aws::String& GetPolicySourceArn() const { return m_policySourceArn; }
  inline bool PolicySourceArnHasBeenSet() const { return m_policySourceArnHasBeenSet; }
  template <typename PolicySourceArnT = Aws::String>
  void SetPolicySourceArn(PolicySourceArnT&& value) {
    m_policySourceArnHasBeenSet = true;
    m_policySourceArn = std::forward<PolicySourceArnT>(value);
  }
  template <typename PolicySourceArnT = Aws::String>
  SimulatePrincipalPolicyRequest& WithPolicySourceArn(PolicySourceArnT&& value) {
    SetPolicySourceArn(std::forward<PolicySourceArnT>(value));
    return *this;
  }
 
 
  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>>
  SimulatePrincipalPolicyRequest& WithPolicyInputList(PolicyInputListT&& value) {
    SetPolicyInputList(std::forward<PolicyInputListT>(value));
    return *this;
  }
  template <typename PolicyInputListT = Aws::String>
  SimulatePrincipalPolicyRequest& 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>>
  SimulatePrincipalPolicyRequest& WithPermissionsBoundaryPolicyInputList(PermissionsBoundaryPolicyInputListT&& value) {
    SetPermissionsBoundaryPolicyInputList(std::forward<PermissionsBoundaryPolicyInputListT>(value));
    return *this;
  }
  template <typename PermissionsBoundaryPolicyInputListT = Aws::String>
  SimulatePrincipalPolicyRequest& AddPermissionsBoundaryPolicyInputList(PermissionsBoundaryPolicyInputListT&& value) {
    m_permissionsBoundaryPolicyInputListHasBeenSet = true;
    m_permissionsBoundaryPolicyInputList.emplace_back(std::forward<PermissionsBoundaryPolicyInputListT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<PolicyIdentifier>& GetPolicyExclusionList() const { return m_policyExclusionList; }
  inline bool PolicyExclusionListHasBeenSet() const { return m_policyExclusionListHasBeenSet; }
  template <typename PolicyExclusionListT = Aws::Vector<PolicyIdentifier>>
  void SetPolicyExclusionList(PolicyExclusionListT&& value) {
    m_policyExclusionListHasBeenSet = true;
    m_policyExclusionList = std::forward<PolicyExclusionListT>(value);
  }
  template <typename PolicyExclusionListT = Aws::Vector<PolicyIdentifier>>
  SimulatePrincipalPolicyRequest& WithPolicyExclusionList(PolicyExclusionListT&& value) {
    SetPolicyExclusionList(std::forward<PolicyExclusionListT>(value));
    return *this;
  }
  template <typename PolicyExclusionListT = PolicyIdentifier>
  SimulatePrincipalPolicyRequest& AddPolicyExclusionList(PolicyExclusionListT&& value) {
    m_policyExclusionListHasBeenSet = true;
    m_policyExclusionList.emplace_back(std::forward<PolicyExclusionListT>(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>>
  SimulatePrincipalPolicyRequest& WithActionNames(ActionNamesT&& value) {
    SetActionNames(std::forward<ActionNamesT>(value));
    return *this;
  }
  template <typename ActionNamesT = Aws::String>
  SimulatePrincipalPolicyRequest& 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>>
  SimulatePrincipalPolicyRequest& WithResourceArns(ResourceArnsT&& value) {
    SetResourceArns(std::forward<ResourceArnsT>(value));
    return *this;
  }
  template <typename ResourceArnsT = Aws::String>
  SimulatePrincipalPolicyRequest& 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>
  SimulatePrincipalPolicyRequest& 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>
  SimulatePrincipalPolicyRequest& 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>
  SimulatePrincipalPolicyRequest& 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>>
  SimulatePrincipalPolicyRequest& WithContextEntries(ContextEntriesT&& value) {
    SetContextEntries(std::forward<ContextEntriesT>(value));
    return *this;
  }
  template <typename ContextEntriesT = ContextEntry>
  SimulatePrincipalPolicyRequest& 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>
  SimulatePrincipalPolicyRequest& 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 SimulatePrincipalPolicyRequest& 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>
  SimulatePrincipalPolicyRequest& WithMarker(MarkerT&& value) {
    SetMarker(std::forward<MarkerT>(value));
    return *this;
  }
 private:
  Aws::String m_policySourceArn;
 
  Aws::Vector<Aws::String> m_policyInputList;
 
  Aws::Vector<Aws::String> m_permissionsBoundaryPolicyInputList;
 
  Aws::Vector<PolicyIdentifier> m_policyExclusionList;
 
  Aws::Vector<Aws::String> m_actionNames;
 
  Aws::Vector<Aws::String> m_resourceArns;
 
  Aws::String m_resourcePolicy;
 
  Aws::String m_resourceOwner;
 
  Aws::String m_callerArn;
 
  Aws::Vector<ContextEntry> m_contextEntries;
 
  Aws::String m_resourceHandlingOption;
 
  int m_maxItems{0};
 
  Aws::String m_marker;
  bool m_policySourceArnHasBeenSet = false;
  bool m_policyInputListHasBeenSet = false;
  bool m_permissionsBoundaryPolicyInputListHasBeenSet = false;
  bool m_policyExclusionListHasBeenSet = false;
  bool m_actionNamesHasBeenSet = false;
  bool m_resourceArnsHasBeenSet = false;
  bool m_resourcePolicyHasBeenSet = false;
  bool m_resourceOwnerHasBeenSet = false;
  bool m_callerArnHasBeenSet = false;
  bool m_contextEntriesHasBeenSet = false;
  bool m_resourceHandlingOptionHasBeenSet = false;
  bool m_maxItemsHasBeenSet = false;
  bool m_markerHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace IAM
}  // namespace Aws