AutomatedReasoningPolicyAnnotation.h

 
#pragma once
#include <aws/bedrock/Bedrock_EXPORTS.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyAddRuleAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyAddRuleFromNaturalLanguageAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyAddTypeAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyAddVariableAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyDeleteRuleAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyDeleteTypeAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyDeleteVariableAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyIngestContentAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyUpdateFromRuleFeedbackAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyUpdateFromScenarioFeedbackAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyUpdateRuleAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyUpdateTypeAnnotation.h>
#include <aws/bedrock/model/AutomatedReasoningPolicyUpdateVariableAnnotation.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Bedrock {
namespace Model {
 
class AutomatedReasoningPolicyAnnotation {
 public:
  AWS_BEDROCK_API AutomatedReasoningPolicyAnnotation() = default;
  AWS_BEDROCK_API AutomatedReasoningPolicyAnnotation(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCK_API AutomatedReasoningPolicyAnnotation& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCK_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const AutomatedReasoningPolicyAddTypeAnnotation& GetAddType() const { return m_addType; }
  inline bool AddTypeHasBeenSet() const { return m_addTypeHasBeenSet; }
  template <typename AddTypeT = AutomatedReasoningPolicyAddTypeAnnotation>
  void SetAddType(AddTypeT&& value) {
    m_addTypeHasBeenSet = true;
    m_addType = std::forward<AddTypeT>(value);
  }
  template <typename AddTypeT = AutomatedReasoningPolicyAddTypeAnnotation>
  AutomatedReasoningPolicyAnnotation& WithAddType(AddTypeT&& value) {
    SetAddType(std::forward<AddTypeT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyUpdateTypeAnnotation& GetUpdateType() const { return m_updateType; }
  inline bool UpdateTypeHasBeenSet() const { return m_updateTypeHasBeenSet; }
  template <typename UpdateTypeT = AutomatedReasoningPolicyUpdateTypeAnnotation>
  void SetUpdateType(UpdateTypeT&& value) {
    m_updateTypeHasBeenSet = true;
    m_updateType = std::forward<UpdateTypeT>(value);
  }
  template <typename UpdateTypeT = AutomatedReasoningPolicyUpdateTypeAnnotation>
  AutomatedReasoningPolicyAnnotation& WithUpdateType(UpdateTypeT&& value) {
    SetUpdateType(std::forward<UpdateTypeT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyDeleteTypeAnnotation& GetDeleteType() const { return m_deleteType; }
  inline bool DeleteTypeHasBeenSet() const { return m_deleteTypeHasBeenSet; }
  template <typename DeleteTypeT = AutomatedReasoningPolicyDeleteTypeAnnotation>
  void SetDeleteType(DeleteTypeT&& value) {
    m_deleteTypeHasBeenSet = true;
    m_deleteType = std::forward<DeleteTypeT>(value);
  }
  template <typename DeleteTypeT = AutomatedReasoningPolicyDeleteTypeAnnotation>
  AutomatedReasoningPolicyAnnotation& WithDeleteType(DeleteTypeT&& value) {
    SetDeleteType(std::forward<DeleteTypeT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyAddVariableAnnotation& GetAddVariable() const { return m_addVariable; }
  inline bool AddVariableHasBeenSet() const { return m_addVariableHasBeenSet; }
  template <typename AddVariableT = AutomatedReasoningPolicyAddVariableAnnotation>
  void SetAddVariable(AddVariableT&& value) {
    m_addVariableHasBeenSet = true;
    m_addVariable = std::forward<AddVariableT>(value);
  }
  template <typename AddVariableT = AutomatedReasoningPolicyAddVariableAnnotation>
  AutomatedReasoningPolicyAnnotation& WithAddVariable(AddVariableT&& value) {
    SetAddVariable(std::forward<AddVariableT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyUpdateVariableAnnotation& GetUpdateVariable() const { return m_updateVariable; }
  inline bool UpdateVariableHasBeenSet() const { return m_updateVariableHasBeenSet; }
  template <typename UpdateVariableT = AutomatedReasoningPolicyUpdateVariableAnnotation>
  void SetUpdateVariable(UpdateVariableT&& value) {
    m_updateVariableHasBeenSet = true;
    m_updateVariable = std::forward<UpdateVariableT>(value);
  }
  template <typename UpdateVariableT = AutomatedReasoningPolicyUpdateVariableAnnotation>
  AutomatedReasoningPolicyAnnotation& WithUpdateVariable(UpdateVariableT&& value) {
    SetUpdateVariable(std::forward<UpdateVariableT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyDeleteVariableAnnotation& GetDeleteVariable() const { return m_deleteVariable; }
  inline bool DeleteVariableHasBeenSet() const { return m_deleteVariableHasBeenSet; }
  template <typename DeleteVariableT = AutomatedReasoningPolicyDeleteVariableAnnotation>
  void SetDeleteVariable(DeleteVariableT&& value) {
    m_deleteVariableHasBeenSet = true;
    m_deleteVariable = std::forward<DeleteVariableT>(value);
  }
  template <typename DeleteVariableT = AutomatedReasoningPolicyDeleteVariableAnnotation>
  AutomatedReasoningPolicyAnnotation& WithDeleteVariable(DeleteVariableT&& value) {
    SetDeleteVariable(std::forward<DeleteVariableT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyAddRuleAnnotation& GetAddRule() const { return m_addRule; }
  inline bool AddRuleHasBeenSet() const { return m_addRuleHasBeenSet; }
  template <typename AddRuleT = AutomatedReasoningPolicyAddRuleAnnotation>
  void SetAddRule(AddRuleT&& value) {
    m_addRuleHasBeenSet = true;
    m_addRule = std::forward<AddRuleT>(value);
  }
  template <typename AddRuleT = AutomatedReasoningPolicyAddRuleAnnotation>
  AutomatedReasoningPolicyAnnotation& WithAddRule(AddRuleT&& value) {
    SetAddRule(std::forward<AddRuleT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyUpdateRuleAnnotation& GetUpdateRule() const { return m_updateRule; }
  inline bool UpdateRuleHasBeenSet() const { return m_updateRuleHasBeenSet; }
  template <typename UpdateRuleT = AutomatedReasoningPolicyUpdateRuleAnnotation>
  void SetUpdateRule(UpdateRuleT&& value) {
    m_updateRuleHasBeenSet = true;
    m_updateRule = std::forward<UpdateRuleT>(value);
  }
  template <typename UpdateRuleT = AutomatedReasoningPolicyUpdateRuleAnnotation>
  AutomatedReasoningPolicyAnnotation& WithUpdateRule(UpdateRuleT&& value) {
    SetUpdateRule(std::forward<UpdateRuleT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyDeleteRuleAnnotation& GetDeleteRule() const { return m_deleteRule; }
  inline bool DeleteRuleHasBeenSet() const { return m_deleteRuleHasBeenSet; }
  template <typename DeleteRuleT = AutomatedReasoningPolicyDeleteRuleAnnotation>
  void SetDeleteRule(DeleteRuleT&& value) {
    m_deleteRuleHasBeenSet = true;
    m_deleteRule = std::forward<DeleteRuleT>(value);
  }
  template <typename DeleteRuleT = AutomatedReasoningPolicyDeleteRuleAnnotation>
  AutomatedReasoningPolicyAnnotation& WithDeleteRule(DeleteRuleT&& value) {
    SetDeleteRule(std::forward<DeleteRuleT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyAddRuleFromNaturalLanguageAnnotation& GetAddRuleFromNaturalLanguage() const {
    return m_addRuleFromNaturalLanguage;
  }
  inline bool AddRuleFromNaturalLanguageHasBeenSet() const { return m_addRuleFromNaturalLanguageHasBeenSet; }
  template <typename AddRuleFromNaturalLanguageT = AutomatedReasoningPolicyAddRuleFromNaturalLanguageAnnotation>
  void SetAddRuleFromNaturalLanguage(AddRuleFromNaturalLanguageT&& value) {
    m_addRuleFromNaturalLanguageHasBeenSet = true;
    m_addRuleFromNaturalLanguage = std::forward<AddRuleFromNaturalLanguageT>(value);
  }
  template <typename AddRuleFromNaturalLanguageT = AutomatedReasoningPolicyAddRuleFromNaturalLanguageAnnotation>
  AutomatedReasoningPolicyAnnotation& WithAddRuleFromNaturalLanguage(AddRuleFromNaturalLanguageT&& value) {
    SetAddRuleFromNaturalLanguage(std::forward<AddRuleFromNaturalLanguageT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyUpdateFromRuleFeedbackAnnotation& GetUpdateFromRulesFeedback() const {
    return m_updateFromRulesFeedback;
  }
  inline bool UpdateFromRulesFeedbackHasBeenSet() const { return m_updateFromRulesFeedbackHasBeenSet; }
  template <typename UpdateFromRulesFeedbackT = AutomatedReasoningPolicyUpdateFromRuleFeedbackAnnotation>
  void SetUpdateFromRulesFeedback(UpdateFromRulesFeedbackT&& value) {
    m_updateFromRulesFeedbackHasBeenSet = true;
    m_updateFromRulesFeedback = std::forward<UpdateFromRulesFeedbackT>(value);
  }
  template <typename UpdateFromRulesFeedbackT = AutomatedReasoningPolicyUpdateFromRuleFeedbackAnnotation>
  AutomatedReasoningPolicyAnnotation& WithUpdateFromRulesFeedback(UpdateFromRulesFeedbackT&& value) {
    SetUpdateFromRulesFeedback(std::forward<UpdateFromRulesFeedbackT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyUpdateFromScenarioFeedbackAnnotation& GetUpdateFromScenarioFeedback() const {
    return m_updateFromScenarioFeedback;
  }
  inline bool UpdateFromScenarioFeedbackHasBeenSet() const { return m_updateFromScenarioFeedbackHasBeenSet; }
  template <typename UpdateFromScenarioFeedbackT = AutomatedReasoningPolicyUpdateFromScenarioFeedbackAnnotation>
  void SetUpdateFromScenarioFeedback(UpdateFromScenarioFeedbackT&& value) {
    m_updateFromScenarioFeedbackHasBeenSet = true;
    m_updateFromScenarioFeedback = std::forward<UpdateFromScenarioFeedbackT>(value);
  }
  template <typename UpdateFromScenarioFeedbackT = AutomatedReasoningPolicyUpdateFromScenarioFeedbackAnnotation>
  AutomatedReasoningPolicyAnnotation& WithUpdateFromScenarioFeedback(UpdateFromScenarioFeedbackT&& value) {
    SetUpdateFromScenarioFeedback(std::forward<UpdateFromScenarioFeedbackT>(value));
    return *this;
  }
 
 
  inline const AutomatedReasoningPolicyIngestContentAnnotation& GetIngestContent() const { return m_ingestContent; }
  inline bool IngestContentHasBeenSet() const { return m_ingestContentHasBeenSet; }
  template <typename IngestContentT = AutomatedReasoningPolicyIngestContentAnnotation>
  void SetIngestContent(IngestContentT&& value) {
    m_ingestContentHasBeenSet = true;
    m_ingestContent = std::forward<IngestContentT>(value);
  }
  template <typename IngestContentT = AutomatedReasoningPolicyIngestContentAnnotation>
  AutomatedReasoningPolicyAnnotation& WithIngestContent(IngestContentT&& value) {
    SetIngestContent(std::forward<IngestContentT>(value));
    return *this;
  }
 private:
  AutomatedReasoningPolicyAddTypeAnnotation m_addType;
 
  AutomatedReasoningPolicyUpdateTypeAnnotation m_updateType;
 
  AutomatedReasoningPolicyDeleteTypeAnnotation m_deleteType;
 
  AutomatedReasoningPolicyAddVariableAnnotation m_addVariable;
 
  AutomatedReasoningPolicyUpdateVariableAnnotation m_updateVariable;
 
  AutomatedReasoningPolicyDeleteVariableAnnotation m_deleteVariable;
 
  AutomatedReasoningPolicyAddRuleAnnotation m_addRule;
 
  AutomatedReasoningPolicyUpdateRuleAnnotation m_updateRule;
 
  AutomatedReasoningPolicyDeleteRuleAnnotation m_deleteRule;
 
  AutomatedReasoningPolicyAddRuleFromNaturalLanguageAnnotation m_addRuleFromNaturalLanguage;
 
  AutomatedReasoningPolicyUpdateFromRuleFeedbackAnnotation m_updateFromRulesFeedback;
 
  AutomatedReasoningPolicyUpdateFromScenarioFeedbackAnnotation m_updateFromScenarioFeedback;
 
  AutomatedReasoningPolicyIngestContentAnnotation m_ingestContent;
  bool m_addTypeHasBeenSet = false;
  bool m_updateTypeHasBeenSet = false;
  bool m_deleteTypeHasBeenSet = false;
  bool m_addVariableHasBeenSet = false;
  bool m_updateVariableHasBeenSet = false;
  bool m_deleteVariableHasBeenSet = false;
  bool m_addRuleHasBeenSet = false;
  bool m_updateRuleHasBeenSet = false;
  bool m_deleteRuleHasBeenSet = false;
  bool m_addRuleFromNaturalLanguageHasBeenSet = false;
  bool m_updateFromRulesFeedbackHasBeenSet = false;
  bool m_updateFromScenarioFeedbackHasBeenSet = false;
  bool m_ingestContentHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Bedrock
}  // namespace Aws