ActionGroupInvocationInput.h

 
#pragma once
#include <aws/bedrock-agent-runtime/BedrockAgentRuntime_EXPORTS.h>
#include <aws/bedrock-agent-runtime/model/ExecutionType.h>
#include <aws/bedrock-agent-runtime/model/Parameter.h>
#include <aws/bedrock-agent-runtime/model/RequestBody.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace BedrockAgentRuntime {
namespace Model {
 
class ActionGroupInvocationInput {
 public:
  AWS_BEDROCKAGENTRUNTIME_API ActionGroupInvocationInput() = default;
  AWS_BEDROCKAGENTRUNTIME_API ActionGroupInvocationInput(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENTRUNTIME_API ActionGroupInvocationInput& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BEDROCKAGENTRUNTIME_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetActionGroupName() const { return m_actionGroupName; }
  inline bool ActionGroupNameHasBeenSet() const { return m_actionGroupNameHasBeenSet; }
  template <typename ActionGroupNameT = Aws::String>
  void SetActionGroupName(ActionGroupNameT&& value) {
    m_actionGroupNameHasBeenSet = true;
    m_actionGroupName = std::forward<ActionGroupNameT>(value);
  }
  template <typename ActionGroupNameT = Aws::String>
  ActionGroupInvocationInput& WithActionGroupName(ActionGroupNameT&& value) {
    SetActionGroupName(std::forward<ActionGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetApiPath() const { return m_apiPath; }
  inline bool ApiPathHasBeenSet() const { return m_apiPathHasBeenSet; }
  template <typename ApiPathT = Aws::String>
  void SetApiPath(ApiPathT&& value) {
    m_apiPathHasBeenSet = true;
    m_apiPath = std::forward<ApiPathT>(value);
  }
  template <typename ApiPathT = Aws::String>
  ActionGroupInvocationInput& WithApiPath(ApiPathT&& value) {
    SetApiPath(std::forward<ApiPathT>(value));
    return *this;
  }
 
 
  inline ExecutionType GetExecutionType() const { return m_executionType; }
  inline bool ExecutionTypeHasBeenSet() const { return m_executionTypeHasBeenSet; }
  inline void SetExecutionType(ExecutionType value) {
    m_executionTypeHasBeenSet = true;
    m_executionType = value;
  }
  inline ActionGroupInvocationInput& WithExecutionType(ExecutionType value) {
    SetExecutionType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetFunction() const { return m_function; }
  inline bool FunctionHasBeenSet() const { return m_functionHasBeenSet; }
  template <typename FunctionT = Aws::String>
  void SetFunction(FunctionT&& value) {
    m_functionHasBeenSet = true;
    m_function = std::forward<FunctionT>(value);
  }
  template <typename FunctionT = Aws::String>
  ActionGroupInvocationInput& WithFunction(FunctionT&& value) {
    SetFunction(std::forward<FunctionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInvocationId() const { return m_invocationId; }
  inline bool InvocationIdHasBeenSet() const { return m_invocationIdHasBeenSet; }
  template <typename InvocationIdT = Aws::String>
  void SetInvocationId(InvocationIdT&& value) {
    m_invocationIdHasBeenSet = true;
    m_invocationId = std::forward<InvocationIdT>(value);
  }
  template <typename InvocationIdT = Aws::String>
  ActionGroupInvocationInput& WithInvocationId(InvocationIdT&& value) {
    SetInvocationId(std::forward<InvocationIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Parameter>& GetParameters() const { return m_parameters; }
  inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
  template <typename ParametersT = Aws::Vector<Parameter>>
  void SetParameters(ParametersT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters = std::forward<ParametersT>(value);
  }
  template <typename ParametersT = Aws::Vector<Parameter>>
  ActionGroupInvocationInput& WithParameters(ParametersT&& value) {
    SetParameters(std::forward<ParametersT>(value));
    return *this;
  }
  template <typename ParametersT = Parameter>
  ActionGroupInvocationInput& AddParameters(ParametersT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters.emplace_back(std::forward<ParametersT>(value));
    return *this;
  }
 
 
  inline const RequestBody& GetRequestBody() const { return m_requestBody; }
  inline bool RequestBodyHasBeenSet() const { return m_requestBodyHasBeenSet; }
  template <typename RequestBodyT = RequestBody>
  void SetRequestBody(RequestBodyT&& value) {
    m_requestBodyHasBeenSet = true;
    m_requestBody = std::forward<RequestBodyT>(value);
  }
  template <typename RequestBodyT = RequestBody>
  ActionGroupInvocationInput& WithRequestBody(RequestBodyT&& value) {
    SetRequestBody(std::forward<RequestBodyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVerb() const { return m_verb; }
  inline bool VerbHasBeenSet() const { return m_verbHasBeenSet; }
  template <typename VerbT = Aws::String>
  void SetVerb(VerbT&& value) {
    m_verbHasBeenSet = true;
    m_verb = std::forward<VerbT>(value);
  }
  template <typename VerbT = Aws::String>
  ActionGroupInvocationInput& WithVerb(VerbT&& value) {
    SetVerb(std::forward<VerbT>(value));
    return *this;
  }
 private:
  Aws::String m_actionGroupName;
 
  Aws::String m_apiPath;
 
  ExecutionType m_executionType{ExecutionType::NOT_SET};
 
  Aws::String m_function;
 
  Aws::String m_invocationId;
 
  Aws::Vector<Parameter> m_parameters;
 
  RequestBody m_requestBody;
 
  Aws::String m_verb;
  bool m_actionGroupNameHasBeenSet = false;
  bool m_apiPathHasBeenSet = false;
  bool m_executionTypeHasBeenSet = false;
  bool m_functionHasBeenSet = false;
  bool m_invocationIdHasBeenSet = false;
  bool m_parametersHasBeenSet = false;
  bool m_requestBodyHasBeenSet = false;
  bool m_verbHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace BedrockAgentRuntime
}  // namespace Aws