ConverseRequest.h

 
#pragma once
#include <aws/bedrock-runtime/BedrockRuntimeRequest.h>
#include <aws/bedrock-runtime/BedrockRuntime_EXPORTS.h>
#include <aws/bedrock-runtime/model/GuardrailConfiguration.h>
#include <aws/bedrock-runtime/model/InferenceConfiguration.h>
#include <aws/bedrock-runtime/model/Message.h>
#include <aws/bedrock-runtime/model/PerformanceConfiguration.h>
#include <aws/bedrock-runtime/model/PromptVariableValues.h>
#include <aws/bedrock-runtime/model/ServiceTier.h>
#include <aws/bedrock-runtime/model/SystemContentBlock.h>
#include <aws/bedrock-runtime/model/ToolConfiguration.h>
#include <aws/core/utils/Document.h>
#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 <utility>
 
namespace Aws {
namespace BedrockRuntime {
namespace Model {
 
class ConverseRequest : public BedrockRuntimeRequest {
 public:
  AWS_BEDROCKRUNTIME_API ConverseRequest() = 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 "Converse"; }
 
  AWS_BEDROCKRUNTIME_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetModelId() const { return m_modelId; }
  inline bool ModelIdHasBeenSet() const { return m_modelIdHasBeenSet; }
  template <typename ModelIdT = Aws::String>
  void SetModelId(ModelIdT&& value) {
    m_modelIdHasBeenSet = true;
    m_modelId = std::forward<ModelIdT>(value);
  }
  template <typename ModelIdT = Aws::String>
  ConverseRequest& WithModelId(ModelIdT&& value) {
    SetModelId(std::forward<ModelIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Message>& GetMessages() const { return m_messages; }
  inline bool MessagesHasBeenSet() const { return m_messagesHasBeenSet; }
  template <typename MessagesT = Aws::Vector<Message>>
  void SetMessages(MessagesT&& value) {
    m_messagesHasBeenSet = true;
    m_messages = std::forward<MessagesT>(value);
  }
  template <typename MessagesT = Aws::Vector<Message>>
  ConverseRequest& WithMessages(MessagesT&& value) {
    SetMessages(std::forward<MessagesT>(value));
    return *this;
  }
  template <typename MessagesT = Message>
  ConverseRequest& AddMessages(MessagesT&& value) {
    m_messagesHasBeenSet = true;
    m_messages.emplace_back(std::forward<MessagesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SystemContentBlock>& GetSystem() const { return m_system; }
  inline bool SystemHasBeenSet() const { return m_systemHasBeenSet; }
  template <typename SystemT = Aws::Vector<SystemContentBlock>>
  void SetSystem(SystemT&& value) {
    m_systemHasBeenSet = true;
    m_system = std::forward<SystemT>(value);
  }
  template <typename SystemT = Aws::Vector<SystemContentBlock>>
  ConverseRequest& WithSystem(SystemT&& value) {
    SetSystem(std::forward<SystemT>(value));
    return *this;
  }
  template <typename SystemT = SystemContentBlock>
  ConverseRequest& AddSystem(SystemT&& value) {
    m_systemHasBeenSet = true;
    m_system.emplace_back(std::forward<SystemT>(value));
    return *this;
  }
 
 
  inline const InferenceConfiguration& GetInferenceConfig() const { return m_inferenceConfig; }
  inline bool InferenceConfigHasBeenSet() const { return m_inferenceConfigHasBeenSet; }
  template <typename InferenceConfigT = InferenceConfiguration>
  void SetInferenceConfig(InferenceConfigT&& value) {
    m_inferenceConfigHasBeenSet = true;
    m_inferenceConfig = std::forward<InferenceConfigT>(value);
  }
  template <typename InferenceConfigT = InferenceConfiguration>
  ConverseRequest& WithInferenceConfig(InferenceConfigT&& value) {
    SetInferenceConfig(std::forward<InferenceConfigT>(value));
    return *this;
  }
 
 
  inline const ToolConfiguration& GetToolConfig() const { return m_toolConfig; }
  inline bool ToolConfigHasBeenSet() const { return m_toolConfigHasBeenSet; }
  template <typename ToolConfigT = ToolConfiguration>
  void SetToolConfig(ToolConfigT&& value) {
    m_toolConfigHasBeenSet = true;
    m_toolConfig = std::forward<ToolConfigT>(value);
  }
  template <typename ToolConfigT = ToolConfiguration>
  ConverseRequest& WithToolConfig(ToolConfigT&& value) {
    SetToolConfig(std::forward<ToolConfigT>(value));
    return *this;
  }
 
 
  inline const GuardrailConfiguration& GetGuardrailConfig() const { return m_guardrailConfig; }
  inline bool GuardrailConfigHasBeenSet() const { return m_guardrailConfigHasBeenSet; }
  template <typename GuardrailConfigT = GuardrailConfiguration>
  void SetGuardrailConfig(GuardrailConfigT&& value) {
    m_guardrailConfigHasBeenSet = true;
    m_guardrailConfig = std::forward<GuardrailConfigT>(value);
  }
  template <typename GuardrailConfigT = GuardrailConfiguration>
  ConverseRequest& WithGuardrailConfig(GuardrailConfigT&& value) {
    SetGuardrailConfig(std::forward<GuardrailConfigT>(value));
    return *this;
  }
 
 
  inline Aws::Utils::DocumentView GetAdditionalModelRequestFields() const { return m_additionalModelRequestFields; }
  inline bool AdditionalModelRequestFieldsHasBeenSet() const { return m_additionalModelRequestFieldsHasBeenSet; }
  template <typename AdditionalModelRequestFieldsT = Aws::Utils::Document>
  void SetAdditionalModelRequestFields(AdditionalModelRequestFieldsT&& value) {
    m_additionalModelRequestFieldsHasBeenSet = true;
    m_additionalModelRequestFields = std::forward<AdditionalModelRequestFieldsT>(value);
  }
  template <typename AdditionalModelRequestFieldsT = Aws::Utils::Document>
  ConverseRequest& WithAdditionalModelRequestFields(AdditionalModelRequestFieldsT&& value) {
    SetAdditionalModelRequestFields(std::forward<AdditionalModelRequestFieldsT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, PromptVariableValues>& GetPromptVariables() const { return m_promptVariables; }
  inline bool PromptVariablesHasBeenSet() const { return m_promptVariablesHasBeenSet; }
  template <typename PromptVariablesT = Aws::Map<Aws::String, PromptVariableValues>>
  void SetPromptVariables(PromptVariablesT&& value) {
    m_promptVariablesHasBeenSet = true;
    m_promptVariables = std::forward<PromptVariablesT>(value);
  }
  template <typename PromptVariablesT = Aws::Map<Aws::String, PromptVariableValues>>
  ConverseRequest& WithPromptVariables(PromptVariablesT&& value) {
    SetPromptVariables(std::forward<PromptVariablesT>(value));
    return *this;
  }
  template <typename PromptVariablesKeyT = Aws::String, typename PromptVariablesValueT = PromptVariableValues>
  ConverseRequest& AddPromptVariables(PromptVariablesKeyT&& key, PromptVariablesValueT&& value) {
    m_promptVariablesHasBeenSet = true;
    m_promptVariables.emplace(std::forward<PromptVariablesKeyT>(key), std::forward<PromptVariablesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAdditionalModelResponseFieldPaths() const { return m_additionalModelResponseFieldPaths; }
  inline bool AdditionalModelResponseFieldPathsHasBeenSet() const { return m_additionalModelResponseFieldPathsHasBeenSet; }
  template <typename AdditionalModelResponseFieldPathsT = Aws::Vector<Aws::String>>
  void SetAdditionalModelResponseFieldPaths(AdditionalModelResponseFieldPathsT&& value) {
    m_additionalModelResponseFieldPathsHasBeenSet = true;
    m_additionalModelResponseFieldPaths = std::forward<AdditionalModelResponseFieldPathsT>(value);
  }
  template <typename AdditionalModelResponseFieldPathsT = Aws::Vector<Aws::String>>
  ConverseRequest& WithAdditionalModelResponseFieldPaths(AdditionalModelResponseFieldPathsT&& value) {
    SetAdditionalModelResponseFieldPaths(std::forward<AdditionalModelResponseFieldPathsT>(value));
    return *this;
  }
  template <typename AdditionalModelResponseFieldPathsT = Aws::String>
  ConverseRequest& AddAdditionalModelResponseFieldPaths(AdditionalModelResponseFieldPathsT&& value) {
    m_additionalModelResponseFieldPathsHasBeenSet = true;
    m_additionalModelResponseFieldPaths.emplace_back(std::forward<AdditionalModelResponseFieldPathsT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetRequestMetadata() const { return m_requestMetadata; }
  inline bool RequestMetadataHasBeenSet() const { return m_requestMetadataHasBeenSet; }
  template <typename RequestMetadataT = Aws::Map<Aws::String, Aws::String>>
  void SetRequestMetadata(RequestMetadataT&& value) {
    m_requestMetadataHasBeenSet = true;
    m_requestMetadata = std::forward<RequestMetadataT>(value);
  }
  template <typename RequestMetadataT = Aws::Map<Aws::String, Aws::String>>
  ConverseRequest& WithRequestMetadata(RequestMetadataT&& value) {
    SetRequestMetadata(std::forward<RequestMetadataT>(value));
    return *this;
  }
  template <typename RequestMetadataKeyT = Aws::String, typename RequestMetadataValueT = Aws::String>
  ConverseRequest& AddRequestMetadata(RequestMetadataKeyT&& key, RequestMetadataValueT&& value) {
    m_requestMetadataHasBeenSet = true;
    m_requestMetadata.emplace(std::forward<RequestMetadataKeyT>(key), std::forward<RequestMetadataValueT>(value));
    return *this;
  }
 
 
  inline const PerformanceConfiguration& GetPerformanceConfig() const { return m_performanceConfig; }
  inline bool PerformanceConfigHasBeenSet() const { return m_performanceConfigHasBeenSet; }
  template <typename PerformanceConfigT = PerformanceConfiguration>
  void SetPerformanceConfig(PerformanceConfigT&& value) {
    m_performanceConfigHasBeenSet = true;
    m_performanceConfig = std::forward<PerformanceConfigT>(value);
  }
  template <typename PerformanceConfigT = PerformanceConfiguration>
  ConverseRequest& WithPerformanceConfig(PerformanceConfigT&& value) {
    SetPerformanceConfig(std::forward<PerformanceConfigT>(value));
    return *this;
  }
 
 
  inline const ServiceTier& GetServiceTier() const { return m_serviceTier; }
  inline bool ServiceTierHasBeenSet() const { return m_serviceTierHasBeenSet; }
  template <typename ServiceTierT = ServiceTier>
  void SetServiceTier(ServiceTierT&& value) {
    m_serviceTierHasBeenSet = true;
    m_serviceTier = std::forward<ServiceTierT>(value);
  }
  template <typename ServiceTierT = ServiceTier>
  ConverseRequest& WithServiceTier(ServiceTierT&& value) {
    SetServiceTier(std::forward<ServiceTierT>(value));
    return *this;
  }
 private:
  Aws::String m_modelId;
  bool m_modelIdHasBeenSet = false;
 
  Aws::Vector<Message> m_messages;
  bool m_messagesHasBeenSet = false;
 
  Aws::Vector<SystemContentBlock> m_system;
  bool m_systemHasBeenSet = false;
 
  InferenceConfiguration m_inferenceConfig;
  bool m_inferenceConfigHasBeenSet = false;
 
  ToolConfiguration m_toolConfig;
  bool m_toolConfigHasBeenSet = false;
 
  GuardrailConfiguration m_guardrailConfig;
  bool m_guardrailConfigHasBeenSet = false;
 
  Aws::Utils::Document m_additionalModelRequestFields;
  bool m_additionalModelRequestFieldsHasBeenSet = false;
 
  Aws::Map<Aws::String, PromptVariableValues> m_promptVariables;
  bool m_promptVariablesHasBeenSet = false;
 
  Aws::Vector<Aws::String> m_additionalModelResponseFieldPaths;
  bool m_additionalModelResponseFieldPathsHasBeenSet = false;
 
  Aws::Map<Aws::String, Aws::String> m_requestMetadata;
  bool m_requestMetadataHasBeenSet = false;
 
  PerformanceConfiguration m_performanceConfig;
  bool m_performanceConfigHasBeenSet = false;
 
  ServiceTier m_serviceTier;
  bool m_serviceTierHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace BedrockRuntime
}  // namespace Aws