Policy.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/fms/FMS_EXPORTS.h>
#include <aws/fms/model/CustomerPolicyScopeIdType.h>
#include <aws/fms/model/CustomerPolicyStatus.h>
#include <aws/fms/model/ResourceTag.h>
#include <aws/fms/model/ResourceTagLogicalOperator.h>
#include <aws/fms/model/SecurityServicePolicyData.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace FMS {
namespace Model {
 
class Policy {
 public:
  AWS_FMS_API Policy() = default;
  AWS_FMS_API Policy(Aws::Utils::Json::JsonView jsonValue);
  AWS_FMS_API Policy& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_FMS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetPolicyId() const { return m_policyId; }
  inline bool PolicyIdHasBeenSet() const { return m_policyIdHasBeenSet; }
  template <typename PolicyIdT = Aws::String>
  void SetPolicyId(PolicyIdT&& value) {
    m_policyIdHasBeenSet = true;
    m_policyId = std::forward<PolicyIdT>(value);
  }
  template <typename PolicyIdT = Aws::String>
  Policy& WithPolicyId(PolicyIdT&& value) {
    SetPolicyId(std::forward<PolicyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPolicyName() const { return m_policyName; }
  inline bool PolicyNameHasBeenSet() const { return m_policyNameHasBeenSet; }
  template <typename PolicyNameT = Aws::String>
  void SetPolicyName(PolicyNameT&& value) {
    m_policyNameHasBeenSet = true;
    m_policyName = std::forward<PolicyNameT>(value);
  }
  template <typename PolicyNameT = Aws::String>
  Policy& WithPolicyName(PolicyNameT&& value) {
    SetPolicyName(std::forward<PolicyNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPolicyUpdateToken() const { return m_policyUpdateToken; }
  inline bool PolicyUpdateTokenHasBeenSet() const { return m_policyUpdateTokenHasBeenSet; }
  template <typename PolicyUpdateTokenT = Aws::String>
  void SetPolicyUpdateToken(PolicyUpdateTokenT&& value) {
    m_policyUpdateTokenHasBeenSet = true;
    m_policyUpdateToken = std::forward<PolicyUpdateTokenT>(value);
  }
  template <typename PolicyUpdateTokenT = Aws::String>
  Policy& WithPolicyUpdateToken(PolicyUpdateTokenT&& value) {
    SetPolicyUpdateToken(std::forward<PolicyUpdateTokenT>(value));
    return *this;
  }
 
 
  inline const SecurityServicePolicyData& GetSecurityServicePolicyData() const { return m_securityServicePolicyData; }
  inline bool SecurityServicePolicyDataHasBeenSet() const { return m_securityServicePolicyDataHasBeenSet; }
  template <typename SecurityServicePolicyDataT = SecurityServicePolicyData>
  void SetSecurityServicePolicyData(SecurityServicePolicyDataT&& value) {
    m_securityServicePolicyDataHasBeenSet = true;
    m_securityServicePolicyData = std::forward<SecurityServicePolicyDataT>(value);
  }
  template <typename SecurityServicePolicyDataT = SecurityServicePolicyData>
  Policy& WithSecurityServicePolicyData(SecurityServicePolicyDataT&& value) {
    SetSecurityServicePolicyData(std::forward<SecurityServicePolicyDataT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResourceType() const { return m_resourceType; }
  inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
  template <typename ResourceTypeT = Aws::String>
  void SetResourceType(ResourceTypeT&& value) {
    m_resourceTypeHasBeenSet = true;
    m_resourceType = std::forward<ResourceTypeT>(value);
  }
  template <typename ResourceTypeT = Aws::String>
  Policy& WithResourceType(ResourceTypeT&& value) {
    SetResourceType(std::forward<ResourceTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetResourceTypeList() const { return m_resourceTypeList; }
  inline bool ResourceTypeListHasBeenSet() const { return m_resourceTypeListHasBeenSet; }
  template <typename ResourceTypeListT = Aws::Vector<Aws::String>>
  void SetResourceTypeList(ResourceTypeListT&& value) {
    m_resourceTypeListHasBeenSet = true;
    m_resourceTypeList = std::forward<ResourceTypeListT>(value);
  }
  template <typename ResourceTypeListT = Aws::Vector<Aws::String>>
  Policy& WithResourceTypeList(ResourceTypeListT&& value) {
    SetResourceTypeList(std::forward<ResourceTypeListT>(value));
    return *this;
  }
  template <typename ResourceTypeListT = Aws::String>
  Policy& AddResourceTypeList(ResourceTypeListT&& value) {
    m_resourceTypeListHasBeenSet = true;
    m_resourceTypeList.emplace_back(std::forward<ResourceTypeListT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ResourceTag>& GetResourceTags() const { return m_resourceTags; }
  inline bool ResourceTagsHasBeenSet() const { return m_resourceTagsHasBeenSet; }
  template <typename ResourceTagsT = Aws::Vector<ResourceTag>>
  void SetResourceTags(ResourceTagsT&& value) {
    m_resourceTagsHasBeenSet = true;
    m_resourceTags = std::forward<ResourceTagsT>(value);
  }
  template <typename ResourceTagsT = Aws::Vector<ResourceTag>>
  Policy& WithResourceTags(ResourceTagsT&& value) {
    SetResourceTags(std::forward<ResourceTagsT>(value));
    return *this;
  }
  template <typename ResourceTagsT = ResourceTag>
  Policy& AddResourceTags(ResourceTagsT&& value) {
    m_resourceTagsHasBeenSet = true;
    m_resourceTags.emplace_back(std::forward<ResourceTagsT>(value));
    return *this;
  }
 
 
  inline bool GetExcludeResourceTags() const { return m_excludeResourceTags; }
  inline bool ExcludeResourceTagsHasBeenSet() const { return m_excludeResourceTagsHasBeenSet; }
  inline void SetExcludeResourceTags(bool value) {
    m_excludeResourceTagsHasBeenSet = true;
    m_excludeResourceTags = value;
  }
  inline Policy& WithExcludeResourceTags(bool value) {
    SetExcludeResourceTags(value);
    return *this;
  }
 
 
  inline bool GetRemediationEnabled() const { return m_remediationEnabled; }
  inline bool RemediationEnabledHasBeenSet() const { return m_remediationEnabledHasBeenSet; }
  inline void SetRemediationEnabled(bool value) {
    m_remediationEnabledHasBeenSet = true;
    m_remediationEnabled = value;
  }
  inline Policy& WithRemediationEnabled(bool value) {
    SetRemediationEnabled(value);
    return *this;
  }
 
 
  inline bool GetDeleteUnusedFMManagedResources() const { return m_deleteUnusedFMManagedResources; }
  inline bool DeleteUnusedFMManagedResourcesHasBeenSet() const { return m_deleteUnusedFMManagedResourcesHasBeenSet; }
  inline void SetDeleteUnusedFMManagedResources(bool value) {
    m_deleteUnusedFMManagedResourcesHasBeenSet = true;
    m_deleteUnusedFMManagedResources = value;
  }
  inline Policy& WithDeleteUnusedFMManagedResources(bool value) {
    SetDeleteUnusedFMManagedResources(value);
    return *this;
  }
 
 
  inline const Aws::Map<CustomerPolicyScopeIdType, Aws::Vector<Aws::String>>& GetIncludeMap() const { return m_includeMap; }
  inline bool IncludeMapHasBeenSet() const { return m_includeMapHasBeenSet; }
  template <typename IncludeMapT = Aws::Map<CustomerPolicyScopeIdType, Aws::Vector<Aws::String>>>
  void SetIncludeMap(IncludeMapT&& value) {
    m_includeMapHasBeenSet = true;
    m_includeMap = std::forward<IncludeMapT>(value);
  }
  template <typename IncludeMapT = Aws::Map<CustomerPolicyScopeIdType, Aws::Vector<Aws::String>>>
  Policy& WithIncludeMap(IncludeMapT&& value) {
    SetIncludeMap(std::forward<IncludeMapT>(value));
    return *this;
  }
  inline Policy& AddIncludeMap(CustomerPolicyScopeIdType key, Aws::Vector<Aws::String> value) {
    m_includeMapHasBeenSet = true;
    m_includeMap.emplace(key, value);
    return *this;
  }
 
 
  inline const Aws::Map<CustomerPolicyScopeIdType, Aws::Vector<Aws::String>>& GetExcludeMap() const { return m_excludeMap; }
  inline bool ExcludeMapHasBeenSet() const { return m_excludeMapHasBeenSet; }
  template <typename ExcludeMapT = Aws::Map<CustomerPolicyScopeIdType, Aws::Vector<Aws::String>>>
  void SetExcludeMap(ExcludeMapT&& value) {
    m_excludeMapHasBeenSet = true;
    m_excludeMap = std::forward<ExcludeMapT>(value);
  }
  template <typename ExcludeMapT = Aws::Map<CustomerPolicyScopeIdType, Aws::Vector<Aws::String>>>
  Policy& WithExcludeMap(ExcludeMapT&& value) {
    SetExcludeMap(std::forward<ExcludeMapT>(value));
    return *this;
  }
  inline Policy& AddExcludeMap(CustomerPolicyScopeIdType key, Aws::Vector<Aws::String> value) {
    m_excludeMapHasBeenSet = true;
    m_excludeMap.emplace(key, value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetResourceSetIds() const { return m_resourceSetIds; }
  inline bool ResourceSetIdsHasBeenSet() const { return m_resourceSetIdsHasBeenSet; }
  template <typename ResourceSetIdsT = Aws::Vector<Aws::String>>
  void SetResourceSetIds(ResourceSetIdsT&& value) {
    m_resourceSetIdsHasBeenSet = true;
    m_resourceSetIds = std::forward<ResourceSetIdsT>(value);
  }
  template <typename ResourceSetIdsT = Aws::Vector<Aws::String>>
  Policy& WithResourceSetIds(ResourceSetIdsT&& value) {
    SetResourceSetIds(std::forward<ResourceSetIdsT>(value));
    return *this;
  }
  template <typename ResourceSetIdsT = Aws::String>
  Policy& AddResourceSetIds(ResourceSetIdsT&& value) {
    m_resourceSetIdsHasBeenSet = true;
    m_resourceSetIds.emplace_back(std::forward<ResourceSetIdsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPolicyDescription() const { return m_policyDescription; }
  inline bool PolicyDescriptionHasBeenSet() const { return m_policyDescriptionHasBeenSet; }
  template <typename PolicyDescriptionT = Aws::String>
  void SetPolicyDescription(PolicyDescriptionT&& value) {
    m_policyDescriptionHasBeenSet = true;
    m_policyDescription = std::forward<PolicyDescriptionT>(value);
  }
  template <typename PolicyDescriptionT = Aws::String>
  Policy& WithPolicyDescription(PolicyDescriptionT&& value) {
    SetPolicyDescription(std::forward<PolicyDescriptionT>(value));
    return *this;
  }
 
 
  inline CustomerPolicyStatus GetPolicyStatus() const { return m_policyStatus; }
  inline bool PolicyStatusHasBeenSet() const { return m_policyStatusHasBeenSet; }
  inline void SetPolicyStatus(CustomerPolicyStatus value) {
    m_policyStatusHasBeenSet = true;
    m_policyStatus = value;
  }
  inline Policy& WithPolicyStatus(CustomerPolicyStatus value) {
    SetPolicyStatus(value);
    return *this;
  }
 
 
  inline ResourceTagLogicalOperator GetResourceTagLogicalOperator() const { return m_resourceTagLogicalOperator; }
  inline bool ResourceTagLogicalOperatorHasBeenSet() const { return m_resourceTagLogicalOperatorHasBeenSet; }
  inline void SetResourceTagLogicalOperator(ResourceTagLogicalOperator value) {
    m_resourceTagLogicalOperatorHasBeenSet = true;
    m_resourceTagLogicalOperator = value;
  }
  inline Policy& WithResourceTagLogicalOperator(ResourceTagLogicalOperator value) {
    SetResourceTagLogicalOperator(value);
    return *this;
  }
 private:
  Aws::String m_policyId;
 
  Aws::String m_policyName;
 
  Aws::String m_policyUpdateToken;
 
  SecurityServicePolicyData m_securityServicePolicyData;
 
  Aws::String m_resourceType;
 
  Aws::Vector<Aws::String> m_resourceTypeList;
 
  Aws::Vector<ResourceTag> m_resourceTags;
 
  bool m_excludeResourceTags{false};
 
  bool m_remediationEnabled{false};
 
  bool m_deleteUnusedFMManagedResources{false};
 
  Aws::Map<CustomerPolicyScopeIdType, Aws::Vector<Aws::String>> m_includeMap;
 
  Aws::Map<CustomerPolicyScopeIdType, Aws::Vector<Aws::String>> m_excludeMap;
 
  Aws::Vector<Aws::String> m_resourceSetIds;
 
  Aws::String m_policyDescription;
 
  CustomerPolicyStatus m_policyStatus{CustomerPolicyStatus::NOT_SET};
 
  ResourceTagLogicalOperator m_resourceTagLogicalOperator{ResourceTagLogicalOperator::NOT_SET};
  bool m_policyIdHasBeenSet = false;
  bool m_policyNameHasBeenSet = false;
  bool m_policyUpdateTokenHasBeenSet = false;
  bool m_securityServicePolicyDataHasBeenSet = false;
  bool m_resourceTypeHasBeenSet = false;
  bool m_resourceTypeListHasBeenSet = false;
  bool m_resourceTagsHasBeenSet = false;
  bool m_excludeResourceTagsHasBeenSet = false;
  bool m_remediationEnabledHasBeenSet = false;
  bool m_deleteUnusedFMManagedResourcesHasBeenSet = false;
  bool m_includeMapHasBeenSet = false;
  bool m_excludeMapHasBeenSet = false;
  bool m_resourceSetIdsHasBeenSet = false;
  bool m_policyDescriptionHasBeenSet = false;
  bool m_policyStatusHasBeenSet = false;
  bool m_resourceTagLogicalOperatorHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace FMS
}  // namespace Aws