GuardrailAssessment.h

 
#pragma once
#include <aws/bedrock-runtime/BedrockRuntime_EXPORTS.h>
#include <aws/bedrock-runtime/model/AppliedGuardrailDetails.h>
#include <aws/bedrock-runtime/model/GuardrailAutomatedReasoningPolicyAssessment.h>
#include <aws/bedrock-runtime/model/GuardrailContentPolicyAssessment.h>
#include <aws/bedrock-runtime/model/GuardrailContextualGroundingPolicyAssessment.h>
#include <aws/bedrock-runtime/model/GuardrailInvocationMetrics.h>
#include <aws/bedrock-runtime/model/GuardrailSensitiveInformationPolicyAssessment.h>
#include <aws/bedrock-runtime/model/GuardrailTopicPolicyAssessment.h>
#include <aws/bedrock-runtime/model/GuardrailWordPolicyAssessment.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace BedrockRuntime {
namespace Model {
 
class GuardrailAssessment {
 public:
  AWS_BEDROCKRUNTIME_API GuardrailAssessment() = default;
  AWS_BEDROCKRUNTIME_API GuardrailAssessment(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKRUNTIME_API GuardrailAssessment& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKRUNTIME_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const GuardrailTopicPolicyAssessment& GetTopicPolicy() const { return m_topicPolicy; }
  inline bool TopicPolicyHasBeenSet() const { return m_topicPolicyHasBeenSet; }
  template <typename TopicPolicyT = GuardrailTopicPolicyAssessment>
  void SetTopicPolicy(TopicPolicyT&& value) {
    m_topicPolicyHasBeenSet = true;
    m_topicPolicy = std::forward<TopicPolicyT>(value);
  }
  template <typename TopicPolicyT = GuardrailTopicPolicyAssessment>
  GuardrailAssessment& WithTopicPolicy(TopicPolicyT&& value) {
    SetTopicPolicy(std::forward<TopicPolicyT>(value));
    return *this;
  }
 
 
  inline const GuardrailContentPolicyAssessment& GetContentPolicy() const { return m_contentPolicy; }
  inline bool ContentPolicyHasBeenSet() const { return m_contentPolicyHasBeenSet; }
  template <typename ContentPolicyT = GuardrailContentPolicyAssessment>
  void SetContentPolicy(ContentPolicyT&& value) {
    m_contentPolicyHasBeenSet = true;
    m_contentPolicy = std::forward<ContentPolicyT>(value);
  }
  template <typename ContentPolicyT = GuardrailContentPolicyAssessment>
  GuardrailAssessment& WithContentPolicy(ContentPolicyT&& value) {
    SetContentPolicy(std::forward<ContentPolicyT>(value));
    return *this;
  }
 
 
  inline const GuardrailWordPolicyAssessment& GetWordPolicy() const { return m_wordPolicy; }
  inline bool WordPolicyHasBeenSet() const { return m_wordPolicyHasBeenSet; }
  template <typename WordPolicyT = GuardrailWordPolicyAssessment>
  void SetWordPolicy(WordPolicyT&& value) {
    m_wordPolicyHasBeenSet = true;
    m_wordPolicy = std::forward<WordPolicyT>(value);
  }
  template <typename WordPolicyT = GuardrailWordPolicyAssessment>
  GuardrailAssessment& WithWordPolicy(WordPolicyT&& value) {
    SetWordPolicy(std::forward<WordPolicyT>(value));
    return *this;
  }
 
 
  inline const GuardrailSensitiveInformationPolicyAssessment& GetSensitiveInformationPolicy() const { return m_sensitiveInformationPolicy; }
  inline bool SensitiveInformationPolicyHasBeenSet() const { return m_sensitiveInformationPolicyHasBeenSet; }
  template <typename SensitiveInformationPolicyT = GuardrailSensitiveInformationPolicyAssessment>
  void SetSensitiveInformationPolicy(SensitiveInformationPolicyT&& value) {
    m_sensitiveInformationPolicyHasBeenSet = true;
    m_sensitiveInformationPolicy = std::forward<SensitiveInformationPolicyT>(value);
  }
  template <typename SensitiveInformationPolicyT = GuardrailSensitiveInformationPolicyAssessment>
  GuardrailAssessment& WithSensitiveInformationPolicy(SensitiveInformationPolicyT&& value) {
    SetSensitiveInformationPolicy(std::forward<SensitiveInformationPolicyT>(value));
    return *this;
  }
 
 
  inline const GuardrailContextualGroundingPolicyAssessment& GetContextualGroundingPolicy() const { return m_contextualGroundingPolicy; }
  inline bool ContextualGroundingPolicyHasBeenSet() const { return m_contextualGroundingPolicyHasBeenSet; }
  template <typename ContextualGroundingPolicyT = GuardrailContextualGroundingPolicyAssessment>
  void SetContextualGroundingPolicy(ContextualGroundingPolicyT&& value) {
    m_contextualGroundingPolicyHasBeenSet = true;
    m_contextualGroundingPolicy = std::forward<ContextualGroundingPolicyT>(value);
  }
  template <typename ContextualGroundingPolicyT = GuardrailContextualGroundingPolicyAssessment>
  GuardrailAssessment& WithContextualGroundingPolicy(ContextualGroundingPolicyT&& value) {
    SetContextualGroundingPolicy(std::forward<ContextualGroundingPolicyT>(value));
    return *this;
  }
 
 
  inline const GuardrailAutomatedReasoningPolicyAssessment& GetAutomatedReasoningPolicy() const { return m_automatedReasoningPolicy; }
  inline bool AutomatedReasoningPolicyHasBeenSet() const { return m_automatedReasoningPolicyHasBeenSet; }
  template <typename AutomatedReasoningPolicyT = GuardrailAutomatedReasoningPolicyAssessment>
  void SetAutomatedReasoningPolicy(AutomatedReasoningPolicyT&& value) {
    m_automatedReasoningPolicyHasBeenSet = true;
    m_automatedReasoningPolicy = std::forward<AutomatedReasoningPolicyT>(value);
  }
  template <typename AutomatedReasoningPolicyT = GuardrailAutomatedReasoningPolicyAssessment>
  GuardrailAssessment& WithAutomatedReasoningPolicy(AutomatedReasoningPolicyT&& value) {
    SetAutomatedReasoningPolicy(std::forward<AutomatedReasoningPolicyT>(value));
    return *this;
  }
 
 
  inline const GuardrailInvocationMetrics& GetInvocationMetrics() const { return m_invocationMetrics; }
  inline bool InvocationMetricsHasBeenSet() const { return m_invocationMetricsHasBeenSet; }
  template <typename InvocationMetricsT = GuardrailInvocationMetrics>
  void SetInvocationMetrics(InvocationMetricsT&& value) {
    m_invocationMetricsHasBeenSet = true;
    m_invocationMetrics = std::forward<InvocationMetricsT>(value);
  }
  template <typename InvocationMetricsT = GuardrailInvocationMetrics>
  GuardrailAssessment& WithInvocationMetrics(InvocationMetricsT&& value) {
    SetInvocationMetrics(std::forward<InvocationMetricsT>(value));
    return *this;
  }
 
 
  inline const AppliedGuardrailDetails& GetAppliedGuardrailDetails() const { return m_appliedGuardrailDetails; }
  inline bool AppliedGuardrailDetailsHasBeenSet() const { return m_appliedGuardrailDetailsHasBeenSet; }
  template <typename AppliedGuardrailDetailsT = AppliedGuardrailDetails>
  void SetAppliedGuardrailDetails(AppliedGuardrailDetailsT&& value) {
    m_appliedGuardrailDetailsHasBeenSet = true;
    m_appliedGuardrailDetails = std::forward<AppliedGuardrailDetailsT>(value);
  }
  template <typename AppliedGuardrailDetailsT = AppliedGuardrailDetails>
  GuardrailAssessment& WithAppliedGuardrailDetails(AppliedGuardrailDetailsT&& value) {
    SetAppliedGuardrailDetails(std::forward<AppliedGuardrailDetailsT>(value));
    return *this;
  }
 private:
  GuardrailTopicPolicyAssessment m_topicPolicy;
 
  GuardrailContentPolicyAssessment m_contentPolicy;
 
  GuardrailWordPolicyAssessment m_wordPolicy;
 
  GuardrailSensitiveInformationPolicyAssessment m_sensitiveInformationPolicy;
 
  GuardrailContextualGroundingPolicyAssessment m_contextualGroundingPolicy;
 
  GuardrailAutomatedReasoningPolicyAssessment m_automatedReasoningPolicy;
 
  GuardrailInvocationMetrics m_invocationMetrics;
 
  AppliedGuardrailDetails m_appliedGuardrailDetails;
  bool m_topicPolicyHasBeenSet = false;
  bool m_contentPolicyHasBeenSet = false;
  bool m_wordPolicyHasBeenSet = false;
  bool m_sensitiveInformationPolicyHasBeenSet = false;
  bool m_contextualGroundingPolicyHasBeenSet = false;
  bool m_automatedReasoningPolicyHasBeenSet = false;
  bool m_invocationMetricsHasBeenSet = false;
  bool m_appliedGuardrailDetailsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace BedrockRuntime
}  // namespace Aws