PolicyGrantDetail.h

 
#pragma once
#include <aws/datazone/DataZone_EXPORTS.h>
#include <aws/datazone/model/AddToProjectMemberPoolPolicyGrantDetail.h>
#include <aws/datazone/model/CreateAssetTypePolicyGrantDetail.h>
#include <aws/datazone/model/CreateDomainUnitPolicyGrantDetail.h>
#include <aws/datazone/model/CreateEnvironmentProfilePolicyGrantDetail.h>
#include <aws/datazone/model/CreateFormTypePolicyGrantDetail.h>
#include <aws/datazone/model/CreateGlossaryPolicyGrantDetail.h>
#include <aws/datazone/model/CreateProjectFromProjectProfilePolicyGrantDetail.h>
#include <aws/datazone/model/CreateProjectPolicyGrantDetail.h>
#include <aws/datazone/model/OverrideDomainUnitOwnersPolicyGrantDetail.h>
#include <aws/datazone/model/OverrideProjectOwnersPolicyGrantDetail.h>
#include <aws/datazone/model/Unit.h>
#include <aws/datazone/model/UseAssetTypePolicyGrantDetail.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DataZone {
namespace Model {
 
class PolicyGrantDetail {
 public:
  AWS_DATAZONE_API PolicyGrantDetail() = default;
  AWS_DATAZONE_API PolicyGrantDetail(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATAZONE_API PolicyGrantDetail& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DATAZONE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const AddToProjectMemberPoolPolicyGrantDetail& GetAddToProjectMemberPool() const { return m_addToProjectMemberPool; }
  inline bool AddToProjectMemberPoolHasBeenSet() const { return m_addToProjectMemberPoolHasBeenSet; }
  template <typename AddToProjectMemberPoolT = AddToProjectMemberPoolPolicyGrantDetail>
  void SetAddToProjectMemberPool(AddToProjectMemberPoolT&& value) {
    m_addToProjectMemberPoolHasBeenSet = true;
    m_addToProjectMemberPool = std::forward<AddToProjectMemberPoolT>(value);
  }
  template <typename AddToProjectMemberPoolT = AddToProjectMemberPoolPolicyGrantDetail>
  PolicyGrantDetail& WithAddToProjectMemberPool(AddToProjectMemberPoolT&& value) {
    SetAddToProjectMemberPool(std::forward<AddToProjectMemberPoolT>(value));
    return *this;
  }
 
 
  inline const CreateAssetTypePolicyGrantDetail& GetCreateAssetType() const { return m_createAssetType; }
  inline bool CreateAssetTypeHasBeenSet() const { return m_createAssetTypeHasBeenSet; }
  template <typename CreateAssetTypeT = CreateAssetTypePolicyGrantDetail>
  void SetCreateAssetType(CreateAssetTypeT&& value) {
    m_createAssetTypeHasBeenSet = true;
    m_createAssetType = std::forward<CreateAssetTypeT>(value);
  }
  template <typename CreateAssetTypeT = CreateAssetTypePolicyGrantDetail>
  PolicyGrantDetail& WithCreateAssetType(CreateAssetTypeT&& value) {
    SetCreateAssetType(std::forward<CreateAssetTypeT>(value));
    return *this;
  }
 
 
  inline const CreateDomainUnitPolicyGrantDetail& GetCreateDomainUnit() const { return m_createDomainUnit; }
  inline bool CreateDomainUnitHasBeenSet() const { return m_createDomainUnitHasBeenSet; }
  template <typename CreateDomainUnitT = CreateDomainUnitPolicyGrantDetail>
  void SetCreateDomainUnit(CreateDomainUnitT&& value) {
    m_createDomainUnitHasBeenSet = true;
    m_createDomainUnit = std::forward<CreateDomainUnitT>(value);
  }
  template <typename CreateDomainUnitT = CreateDomainUnitPolicyGrantDetail>
  PolicyGrantDetail& WithCreateDomainUnit(CreateDomainUnitT&& value) {
    SetCreateDomainUnit(std::forward<CreateDomainUnitT>(value));
    return *this;
  }
 
 
  inline const Unit& GetCreateEnvironment() const { return m_createEnvironment; }
  inline bool CreateEnvironmentHasBeenSet() const { return m_createEnvironmentHasBeenSet; }
  template <typename CreateEnvironmentT = Unit>
  void SetCreateEnvironment(CreateEnvironmentT&& value) {
    m_createEnvironmentHasBeenSet = true;
    m_createEnvironment = std::forward<CreateEnvironmentT>(value);
  }
  template <typename CreateEnvironmentT = Unit>
  PolicyGrantDetail& WithCreateEnvironment(CreateEnvironmentT&& value) {
    SetCreateEnvironment(std::forward<CreateEnvironmentT>(value));
    return *this;
  }
 
 
  inline const Unit& GetCreateEnvironmentFromBlueprint() const { return m_createEnvironmentFromBlueprint; }
  inline bool CreateEnvironmentFromBlueprintHasBeenSet() const { return m_createEnvironmentFromBlueprintHasBeenSet; }
  template <typename CreateEnvironmentFromBlueprintT = Unit>
  void SetCreateEnvironmentFromBlueprint(CreateEnvironmentFromBlueprintT&& value) {
    m_createEnvironmentFromBlueprintHasBeenSet = true;
    m_createEnvironmentFromBlueprint = std::forward<CreateEnvironmentFromBlueprintT>(value);
  }
  template <typename CreateEnvironmentFromBlueprintT = Unit>
  PolicyGrantDetail& WithCreateEnvironmentFromBlueprint(CreateEnvironmentFromBlueprintT&& value) {
    SetCreateEnvironmentFromBlueprint(std::forward<CreateEnvironmentFromBlueprintT>(value));
    return *this;
  }
 
 
  inline const CreateEnvironmentProfilePolicyGrantDetail& GetCreateEnvironmentProfile() const { return m_createEnvironmentProfile; }
  inline bool CreateEnvironmentProfileHasBeenSet() const { return m_createEnvironmentProfileHasBeenSet; }
  template <typename CreateEnvironmentProfileT = CreateEnvironmentProfilePolicyGrantDetail>
  void SetCreateEnvironmentProfile(CreateEnvironmentProfileT&& value) {
    m_createEnvironmentProfileHasBeenSet = true;
    m_createEnvironmentProfile = std::forward<CreateEnvironmentProfileT>(value);
  }
  template <typename CreateEnvironmentProfileT = CreateEnvironmentProfilePolicyGrantDetail>
  PolicyGrantDetail& WithCreateEnvironmentProfile(CreateEnvironmentProfileT&& value) {
    SetCreateEnvironmentProfile(std::forward<CreateEnvironmentProfileT>(value));
    return *this;
  }
 
 
  inline const CreateFormTypePolicyGrantDetail& GetCreateFormType() const { return m_createFormType; }
  inline bool CreateFormTypeHasBeenSet() const { return m_createFormTypeHasBeenSet; }
  template <typename CreateFormTypeT = CreateFormTypePolicyGrantDetail>
  void SetCreateFormType(CreateFormTypeT&& value) {
    m_createFormTypeHasBeenSet = true;
    m_createFormType = std::forward<CreateFormTypeT>(value);
  }
  template <typename CreateFormTypeT = CreateFormTypePolicyGrantDetail>
  PolicyGrantDetail& WithCreateFormType(CreateFormTypeT&& value) {
    SetCreateFormType(std::forward<CreateFormTypeT>(value));
    return *this;
  }
 
 
  inline const CreateGlossaryPolicyGrantDetail& GetCreateGlossary() const { return m_createGlossary; }
  inline bool CreateGlossaryHasBeenSet() const { return m_createGlossaryHasBeenSet; }
  template <typename CreateGlossaryT = CreateGlossaryPolicyGrantDetail>
  void SetCreateGlossary(CreateGlossaryT&& value) {
    m_createGlossaryHasBeenSet = true;
    m_createGlossary = std::forward<CreateGlossaryT>(value);
  }
  template <typename CreateGlossaryT = CreateGlossaryPolicyGrantDetail>
  PolicyGrantDetail& WithCreateGlossary(CreateGlossaryT&& value) {
    SetCreateGlossary(std::forward<CreateGlossaryT>(value));
    return *this;
  }
 
 
  inline const CreateProjectPolicyGrantDetail& GetCreateProject() const { return m_createProject; }
  inline bool CreateProjectHasBeenSet() const { return m_createProjectHasBeenSet; }
  template <typename CreateProjectT = CreateProjectPolicyGrantDetail>
  void SetCreateProject(CreateProjectT&& value) {
    m_createProjectHasBeenSet = true;
    m_createProject = std::forward<CreateProjectT>(value);
  }
  template <typename CreateProjectT = CreateProjectPolicyGrantDetail>
  PolicyGrantDetail& WithCreateProject(CreateProjectT&& value) {
    SetCreateProject(std::forward<CreateProjectT>(value));
    return *this;
  }
 
 
  inline const CreateProjectFromProjectProfilePolicyGrantDetail& GetCreateProjectFromProjectProfile() const {
    return m_createProjectFromProjectProfile;
  }
  inline bool CreateProjectFromProjectProfileHasBeenSet() const { return m_createProjectFromProjectProfileHasBeenSet; }
  template <typename CreateProjectFromProjectProfileT = CreateProjectFromProjectProfilePolicyGrantDetail>
  void SetCreateProjectFromProjectProfile(CreateProjectFromProjectProfileT&& value) {
    m_createProjectFromProjectProfileHasBeenSet = true;
    m_createProjectFromProjectProfile = std::forward<CreateProjectFromProjectProfileT>(value);
  }
  template <typename CreateProjectFromProjectProfileT = CreateProjectFromProjectProfilePolicyGrantDetail>
  PolicyGrantDetail& WithCreateProjectFromProjectProfile(CreateProjectFromProjectProfileT&& value) {
    SetCreateProjectFromProjectProfile(std::forward<CreateProjectFromProjectProfileT>(value));
    return *this;
  }
 
 
  inline const Unit& GetDelegateCreateEnvironmentProfile() const { return m_delegateCreateEnvironmentProfile; }
  inline bool DelegateCreateEnvironmentProfileHasBeenSet() const { return m_delegateCreateEnvironmentProfileHasBeenSet; }
  template <typename DelegateCreateEnvironmentProfileT = Unit>
  void SetDelegateCreateEnvironmentProfile(DelegateCreateEnvironmentProfileT&& value) {
    m_delegateCreateEnvironmentProfileHasBeenSet = true;
    m_delegateCreateEnvironmentProfile = std::forward<DelegateCreateEnvironmentProfileT>(value);
  }
  template <typename DelegateCreateEnvironmentProfileT = Unit>
  PolicyGrantDetail& WithDelegateCreateEnvironmentProfile(DelegateCreateEnvironmentProfileT&& value) {
    SetDelegateCreateEnvironmentProfile(std::forward<DelegateCreateEnvironmentProfileT>(value));
    return *this;
  }
 
 
  inline const OverrideDomainUnitOwnersPolicyGrantDetail& GetOverrideDomainUnitOwners() const { return m_overrideDomainUnitOwners; }
  inline bool OverrideDomainUnitOwnersHasBeenSet() const { return m_overrideDomainUnitOwnersHasBeenSet; }
  template <typename OverrideDomainUnitOwnersT = OverrideDomainUnitOwnersPolicyGrantDetail>
  void SetOverrideDomainUnitOwners(OverrideDomainUnitOwnersT&& value) {
    m_overrideDomainUnitOwnersHasBeenSet = true;
    m_overrideDomainUnitOwners = std::forward<OverrideDomainUnitOwnersT>(value);
  }
  template <typename OverrideDomainUnitOwnersT = OverrideDomainUnitOwnersPolicyGrantDetail>
  PolicyGrantDetail& WithOverrideDomainUnitOwners(OverrideDomainUnitOwnersT&& value) {
    SetOverrideDomainUnitOwners(std::forward<OverrideDomainUnitOwnersT>(value));
    return *this;
  }
 
 
  inline const OverrideProjectOwnersPolicyGrantDetail& GetOverrideProjectOwners() const { return m_overrideProjectOwners; }
  inline bool OverrideProjectOwnersHasBeenSet() const { return m_overrideProjectOwnersHasBeenSet; }
  template <typename OverrideProjectOwnersT = OverrideProjectOwnersPolicyGrantDetail>
  void SetOverrideProjectOwners(OverrideProjectOwnersT&& value) {
    m_overrideProjectOwnersHasBeenSet = true;
    m_overrideProjectOwners = std::forward<OverrideProjectOwnersT>(value);
  }
  template <typename OverrideProjectOwnersT = OverrideProjectOwnersPolicyGrantDetail>
  PolicyGrantDetail& WithOverrideProjectOwners(OverrideProjectOwnersT&& value) {
    SetOverrideProjectOwners(std::forward<OverrideProjectOwnersT>(value));
    return *this;
  }
 
 
  inline const UseAssetTypePolicyGrantDetail& GetUseAssetType() const { return m_useAssetType; }
  inline bool UseAssetTypeHasBeenSet() const { return m_useAssetTypeHasBeenSet; }
  template <typename UseAssetTypeT = UseAssetTypePolicyGrantDetail>
  void SetUseAssetType(UseAssetTypeT&& value) {
    m_useAssetTypeHasBeenSet = true;
    m_useAssetType = std::forward<UseAssetTypeT>(value);
  }
  template <typename UseAssetTypeT = UseAssetTypePolicyGrantDetail>
  PolicyGrantDetail& WithUseAssetType(UseAssetTypeT&& value) {
    SetUseAssetType(std::forward<UseAssetTypeT>(value));
    return *this;
  }
 private:
  AddToProjectMemberPoolPolicyGrantDetail m_addToProjectMemberPool;
  bool m_addToProjectMemberPoolHasBeenSet = false;
 
  CreateAssetTypePolicyGrantDetail m_createAssetType;
  bool m_createAssetTypeHasBeenSet = false;
 
  CreateDomainUnitPolicyGrantDetail m_createDomainUnit;
  bool m_createDomainUnitHasBeenSet = false;
 
  Unit m_createEnvironment;
  bool m_createEnvironmentHasBeenSet = false;
 
  Unit m_createEnvironmentFromBlueprint;
  bool m_createEnvironmentFromBlueprintHasBeenSet = false;
 
  CreateEnvironmentProfilePolicyGrantDetail m_createEnvironmentProfile;
  bool m_createEnvironmentProfileHasBeenSet = false;
 
  CreateFormTypePolicyGrantDetail m_createFormType;
  bool m_createFormTypeHasBeenSet = false;
 
  CreateGlossaryPolicyGrantDetail m_createGlossary;
  bool m_createGlossaryHasBeenSet = false;
 
  CreateProjectPolicyGrantDetail m_createProject;
  bool m_createProjectHasBeenSet = false;
 
  CreateProjectFromProjectProfilePolicyGrantDetail m_createProjectFromProjectProfile;
  bool m_createProjectFromProjectProfileHasBeenSet = false;
 
  Unit m_delegateCreateEnvironmentProfile;
  bool m_delegateCreateEnvironmentProfileHasBeenSet = false;
 
  OverrideDomainUnitOwnersPolicyGrantDetail m_overrideDomainUnitOwners;
  bool m_overrideDomainUnitOwnersHasBeenSet = false;
 
  OverrideProjectOwnersPolicyGrantDetail m_overrideProjectOwners;
  bool m_overrideProjectOwnersHasBeenSet = false;
 
  UseAssetTypePolicyGrantDetail m_useAssetType;
  bool m_useAssetTypeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DataZone
}  // namespace Aws