CreateGuardrailRequest.h

 
#pragma once
#include <aws/bedrock/BedrockRequest.h>
#include <aws/bedrock/Bedrock_EXPORTS.h>
#include <aws/bedrock/model/GuardrailAutomatedReasoningPolicyConfig.h>
#include <aws/bedrock/model/GuardrailContentPolicyConfig.h>
#include <aws/bedrock/model/GuardrailContextualGroundingPolicyConfig.h>
#include <aws/bedrock/model/GuardrailCrossRegionConfig.h>
#include <aws/bedrock/model/GuardrailSensitiveInformationPolicyConfig.h>
#include <aws/bedrock/model/GuardrailTopicPolicyConfig.h>
#include <aws/bedrock/model/GuardrailWordPolicyConfig.h>
#include <aws/bedrock/model/Tag.h>
#include <aws/core/utils/UUID.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Bedrock {
namespace Model {
 
class CreateGuardrailRequest : public BedrockRequest {
 public:
  AWS_BEDROCK_API CreateGuardrailRequest() = 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 "CreateGuardrail"; }
 
  AWS_BEDROCK_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  CreateGuardrailRequest& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  CreateGuardrailRequest& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const GuardrailTopicPolicyConfig& GetTopicPolicyConfig() const { return m_topicPolicyConfig; }
  inline bool TopicPolicyConfigHasBeenSet() const { return m_topicPolicyConfigHasBeenSet; }
  template <typename TopicPolicyConfigT = GuardrailTopicPolicyConfig>
  void SetTopicPolicyConfig(TopicPolicyConfigT&& value) {
    m_topicPolicyConfigHasBeenSet = true;
    m_topicPolicyConfig = std::forward<TopicPolicyConfigT>(value);
  }
  template <typename TopicPolicyConfigT = GuardrailTopicPolicyConfig>
  CreateGuardrailRequest& WithTopicPolicyConfig(TopicPolicyConfigT&& value) {
    SetTopicPolicyConfig(std::forward<TopicPolicyConfigT>(value));
    return *this;
  }
 
 
  inline const GuardrailContentPolicyConfig& GetContentPolicyConfig() const { return m_contentPolicyConfig; }
  inline bool ContentPolicyConfigHasBeenSet() const { return m_contentPolicyConfigHasBeenSet; }
  template <typename ContentPolicyConfigT = GuardrailContentPolicyConfig>
  void SetContentPolicyConfig(ContentPolicyConfigT&& value) {
    m_contentPolicyConfigHasBeenSet = true;
    m_contentPolicyConfig = std::forward<ContentPolicyConfigT>(value);
  }
  template <typename ContentPolicyConfigT = GuardrailContentPolicyConfig>
  CreateGuardrailRequest& WithContentPolicyConfig(ContentPolicyConfigT&& value) {
    SetContentPolicyConfig(std::forward<ContentPolicyConfigT>(value));
    return *this;
  }
 
 
  inline const GuardrailWordPolicyConfig& GetWordPolicyConfig() const { return m_wordPolicyConfig; }
  inline bool WordPolicyConfigHasBeenSet() const { return m_wordPolicyConfigHasBeenSet; }
  template <typename WordPolicyConfigT = GuardrailWordPolicyConfig>
  void SetWordPolicyConfig(WordPolicyConfigT&& value) {
    m_wordPolicyConfigHasBeenSet = true;
    m_wordPolicyConfig = std::forward<WordPolicyConfigT>(value);
  }
  template <typename WordPolicyConfigT = GuardrailWordPolicyConfig>
  CreateGuardrailRequest& WithWordPolicyConfig(WordPolicyConfigT&& value) {
    SetWordPolicyConfig(std::forward<WordPolicyConfigT>(value));
    return *this;
  }
 
 
  inline const GuardrailSensitiveInformationPolicyConfig& GetSensitiveInformationPolicyConfig() const {
    return m_sensitiveInformationPolicyConfig;
  }
  inline bool SensitiveInformationPolicyConfigHasBeenSet() const { return m_sensitiveInformationPolicyConfigHasBeenSet; }
  template <typename SensitiveInformationPolicyConfigT = GuardrailSensitiveInformationPolicyConfig>
  void SetSensitiveInformationPolicyConfig(SensitiveInformationPolicyConfigT&& value) {
    m_sensitiveInformationPolicyConfigHasBeenSet = true;
    m_sensitiveInformationPolicyConfig = std::forward<SensitiveInformationPolicyConfigT>(value);
  }
  template <typename SensitiveInformationPolicyConfigT = GuardrailSensitiveInformationPolicyConfig>
  CreateGuardrailRequest& WithSensitiveInformationPolicyConfig(SensitiveInformationPolicyConfigT&& value) {
    SetSensitiveInformationPolicyConfig(std::forward<SensitiveInformationPolicyConfigT>(value));
    return *this;
  }
 
 
  inline const GuardrailContextualGroundingPolicyConfig& GetContextualGroundingPolicyConfig() const {
    return m_contextualGroundingPolicyConfig;
  }
  inline bool ContextualGroundingPolicyConfigHasBeenSet() const { return m_contextualGroundingPolicyConfigHasBeenSet; }
  template <typename ContextualGroundingPolicyConfigT = GuardrailContextualGroundingPolicyConfig>
  void SetContextualGroundingPolicyConfig(ContextualGroundingPolicyConfigT&& value) {
    m_contextualGroundingPolicyConfigHasBeenSet = true;
    m_contextualGroundingPolicyConfig = std::forward<ContextualGroundingPolicyConfigT>(value);
  }
  template <typename ContextualGroundingPolicyConfigT = GuardrailContextualGroundingPolicyConfig>
  CreateGuardrailRequest& WithContextualGroundingPolicyConfig(ContextualGroundingPolicyConfigT&& value) {
    SetContextualGroundingPolicyConfig(std::forward<ContextualGroundingPolicyConfigT>(value));
    return *this;
  }
 
 
  inline const GuardrailAutomatedReasoningPolicyConfig& GetAutomatedReasoningPolicyConfig() const {
    return m_automatedReasoningPolicyConfig;
  }
  inline bool AutomatedReasoningPolicyConfigHasBeenSet() const { return m_automatedReasoningPolicyConfigHasBeenSet; }
  template <typename AutomatedReasoningPolicyConfigT = GuardrailAutomatedReasoningPolicyConfig>
  void SetAutomatedReasoningPolicyConfig(AutomatedReasoningPolicyConfigT&& value) {
    m_automatedReasoningPolicyConfigHasBeenSet = true;
    m_automatedReasoningPolicyConfig = std::forward<AutomatedReasoningPolicyConfigT>(value);
  }
  template <typename AutomatedReasoningPolicyConfigT = GuardrailAutomatedReasoningPolicyConfig>
  CreateGuardrailRequest& WithAutomatedReasoningPolicyConfig(AutomatedReasoningPolicyConfigT&& value) {
    SetAutomatedReasoningPolicyConfig(std::forward<AutomatedReasoningPolicyConfigT>(value));
    return *this;
  }
 
 
  inline const GuardrailCrossRegionConfig& GetCrossRegionConfig() const { return m_crossRegionConfig; }
  inline bool CrossRegionConfigHasBeenSet() const { return m_crossRegionConfigHasBeenSet; }
  template <typename CrossRegionConfigT = GuardrailCrossRegionConfig>
  void SetCrossRegionConfig(CrossRegionConfigT&& value) {
    m_crossRegionConfigHasBeenSet = true;
    m_crossRegionConfig = std::forward<CrossRegionConfigT>(value);
  }
  template <typename CrossRegionConfigT = GuardrailCrossRegionConfig>
  CreateGuardrailRequest& WithCrossRegionConfig(CrossRegionConfigT&& value) {
    SetCrossRegionConfig(std::forward<CrossRegionConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBlockedInputMessaging() const { return m_blockedInputMessaging; }
  inline bool BlockedInputMessagingHasBeenSet() const { return m_blockedInputMessagingHasBeenSet; }
  template <typename BlockedInputMessagingT = Aws::String>
  void SetBlockedInputMessaging(BlockedInputMessagingT&& value) {
    m_blockedInputMessagingHasBeenSet = true;
    m_blockedInputMessaging = std::forward<BlockedInputMessagingT>(value);
  }
  template <typename BlockedInputMessagingT = Aws::String>
  CreateGuardrailRequest& WithBlockedInputMessaging(BlockedInputMessagingT&& value) {
    SetBlockedInputMessaging(std::forward<BlockedInputMessagingT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBlockedOutputsMessaging() const { return m_blockedOutputsMessaging; }
  inline bool BlockedOutputsMessagingHasBeenSet() const { return m_blockedOutputsMessagingHasBeenSet; }
  template <typename BlockedOutputsMessagingT = Aws::String>
  void SetBlockedOutputsMessaging(BlockedOutputsMessagingT&& value) {
    m_blockedOutputsMessagingHasBeenSet = true;
    m_blockedOutputsMessaging = std::forward<BlockedOutputsMessagingT>(value);
  }
  template <typename BlockedOutputsMessagingT = Aws::String>
  CreateGuardrailRequest& WithBlockedOutputsMessaging(BlockedOutputsMessagingT&& value) {
    SetBlockedOutputsMessaging(std::forward<BlockedOutputsMessagingT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKmsKeyId() const { return m_kmsKeyId; }
  inline bool KmsKeyIdHasBeenSet() const { return m_kmsKeyIdHasBeenSet; }
  template <typename KmsKeyIdT = Aws::String>
  void SetKmsKeyId(KmsKeyIdT&& value) {
    m_kmsKeyIdHasBeenSet = true;
    m_kmsKeyId = std::forward<KmsKeyIdT>(value);
  }
  template <typename KmsKeyIdT = Aws::String>
  CreateGuardrailRequest& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  CreateGuardrailRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CreateGuardrailRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClientRequestToken() const { return m_clientRequestToken; }
  inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
  template <typename ClientRequestTokenT = Aws::String>
  void SetClientRequestToken(ClientRequestTokenT&& value) {
    m_clientRequestTokenHasBeenSet = true;
    m_clientRequestToken = std::forward<ClientRequestTokenT>(value);
  }
  template <typename ClientRequestTokenT = Aws::String>
  CreateGuardrailRequest& WithClientRequestToken(ClientRequestTokenT&& value) {
    SetClientRequestToken(std::forward<ClientRequestTokenT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  Aws::String m_description;
 
  GuardrailTopicPolicyConfig m_topicPolicyConfig;
 
  GuardrailContentPolicyConfig m_contentPolicyConfig;
 
  GuardrailWordPolicyConfig m_wordPolicyConfig;
 
  GuardrailSensitiveInformationPolicyConfig m_sensitiveInformationPolicyConfig;
 
  GuardrailContextualGroundingPolicyConfig m_contextualGroundingPolicyConfig;
 
  GuardrailAutomatedReasoningPolicyConfig m_automatedReasoningPolicyConfig;
 
  GuardrailCrossRegionConfig m_crossRegionConfig;
 
  Aws::String m_blockedInputMessaging;
 
  Aws::String m_blockedOutputsMessaging;
 
  Aws::String m_kmsKeyId;
 
  Aws::Vector<Tag> m_tags;
 
  Aws::String m_clientRequestToken{Aws::Utils::UUID::PseudoRandomUUID()};
  bool m_nameHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_topicPolicyConfigHasBeenSet = false;
  bool m_contentPolicyConfigHasBeenSet = false;
  bool m_wordPolicyConfigHasBeenSet = false;
  bool m_sensitiveInformationPolicyConfigHasBeenSet = false;
  bool m_contextualGroundingPolicyConfigHasBeenSet = false;
  bool m_automatedReasoningPolicyConfigHasBeenSet = false;
  bool m_crossRegionConfigHasBeenSet = false;
  bool m_blockedInputMessagingHasBeenSet = false;
  bool m_blockedOutputsMessagingHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_clientRequestTokenHasBeenSet = true;
};
 
}  // namespace Model
}  // namespace Bedrock
}  // namespace Aws