BedrockAgentRuntimeClient.h

 
#pragma once
#include <aws/bedrock-agent-runtime/BedrockAgentRuntimeErrorMarshaller.h>
#include <aws/bedrock-agent-runtime/BedrockAgentRuntimePaginationBase.h>
#include <aws/bedrock-agent-runtime/BedrockAgentRuntimeServiceClientModel.h>
#include <aws/bedrock-agent-runtime/BedrockAgentRuntimeWaiter.h>
#include <aws/bedrock-agent-runtime/BedrockAgentRuntime_EXPORTS.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <smithy/client/AwsSmithyClient.h>
#include <smithy/client/serializer/JsonOutcomeSerializer.h>
#include <smithy/identity/auth/built-in/GenericAuthSchemeResolver.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
 
namespace Aws {
namespace BedrockAgentRuntime {
AWS_BEDROCKAGENTRUNTIME_API extern const char SERVICE_NAME[];
class AWS_BEDROCKAGENTRUNTIME_API BedrockAgentRuntimeClient
    : Aws::Client::ClientWithAsyncTemplateMethods<BedrockAgentRuntimeClient>,
      public smithy::client::AwsSmithyClientT<
          Aws::BedrockAgentRuntime::SERVICE_NAME, Aws::BedrockAgentRuntime::BedrockAgentRuntimeClientConfiguration,
          smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant<smithy::SigV4AuthScheme>, BedrockAgentRuntimeEndpointProviderBase,
          smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockAgentRuntimeErrorMarshaller>,
      public BedrockAgentRuntimePaginationBase<BedrockAgentRuntimeClient>,
      public BedrockAgentRuntimeWaiter<BedrockAgentRuntimeClient> {
 public:
  static const char* GetServiceName();
  static const char* GetAllocationTag();
  inline const char* GetServiceClientName() const override { return "Bedrock Agent Runtime"; }
 
  typedef BedrockAgentRuntimeClientConfiguration ClientConfigurationType;
  typedef BedrockAgentRuntimeEndpointProvider EndpointProviderType;
 
  BedrockAgentRuntimeClient(const Aws::BedrockAgentRuntime::BedrockAgentRuntimeClientConfiguration& clientConfiguration =
                                Aws::BedrockAgentRuntime::BedrockAgentRuntimeClientConfiguration(),
                            std::shared_ptr<BedrockAgentRuntimeEndpointProviderBase> endpointProvider = nullptr);
 
  BedrockAgentRuntimeClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<BedrockAgentRuntimeEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::BedrockAgentRuntime::BedrockAgentRuntimeClientConfiguration& clientConfiguration =
                                Aws::BedrockAgentRuntime::BedrockAgentRuntimeClientConfiguration());
 
  BedrockAgentRuntimeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<BedrockAgentRuntimeEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::BedrockAgentRuntime::BedrockAgentRuntimeClientConfiguration& clientConfiguration =
                                Aws::BedrockAgentRuntime::BedrockAgentRuntimeClientConfiguration());
 
  /* Legacy constructors due deprecation */
  BedrockAgentRuntimeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BedrockAgentRuntimeClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BedrockAgentRuntimeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~BedrockAgentRuntimeClient();
 
  virtual Model::AgenticRetrieveStreamOutcome AgenticRetrieveStream(Model::AgenticRetrieveStreamRequest& request) const;
 
  template <typename AgenticRetrieveStreamRequestT = Model::AgenticRetrieveStreamRequest>
  Model::AgenticRetrieveStreamOutcomeCallable AgenticRetrieveStreamCallable(AgenticRetrieveStreamRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::AgenticRetrieveStream, request);
  }
 
  template <typename AgenticRetrieveStreamRequestT = Model::AgenticRetrieveStreamRequest>
  void AgenticRetrieveStreamAsync(AgenticRetrieveStreamRequestT& request, const AgenticRetrieveStreamResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::AgenticRetrieveStream, request, handler, context);
  }
 
  virtual Model::CreateInvocationOutcome CreateInvocation(const Model::CreateInvocationRequest& request) const;
 
  template <typename CreateInvocationRequestT = Model::CreateInvocationRequest>
  Model::CreateInvocationOutcomeCallable CreateInvocationCallable(const CreateInvocationRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::CreateInvocation, request);
  }
 
  template <typename CreateInvocationRequestT = Model::CreateInvocationRequest>
  void CreateInvocationAsync(const CreateInvocationRequestT& request, const CreateInvocationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::CreateInvocation, request, handler, context);
  }
 
  virtual Model::CreateSessionOutcome CreateSession(const Model::CreateSessionRequest& request = {}) const;
 
  template <typename CreateSessionRequestT = Model::CreateSessionRequest>
  Model::CreateSessionOutcomeCallable CreateSessionCallable(const CreateSessionRequestT& request = {}) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::CreateSession, request);
  }
 
  template <typename CreateSessionRequestT = Model::CreateSessionRequest>
  void CreateSessionAsync(const CreateSessionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const CreateSessionRequestT& request = {}) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::CreateSession, request, handler, context);
  }
 
  virtual Model::DeleteAgentMemoryOutcome DeleteAgentMemory(const Model::DeleteAgentMemoryRequest& request) const;
 
  template <typename DeleteAgentMemoryRequestT = Model::DeleteAgentMemoryRequest>
  Model::DeleteAgentMemoryOutcomeCallable DeleteAgentMemoryCallable(const DeleteAgentMemoryRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::DeleteAgentMemory, request);
  }
 
  template <typename DeleteAgentMemoryRequestT = Model::DeleteAgentMemoryRequest>
  void DeleteAgentMemoryAsync(const DeleteAgentMemoryRequestT& request, const DeleteAgentMemoryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::DeleteAgentMemory, request, handler, context);
  }
 
  virtual Model::DeleteSessionOutcome DeleteSession(const Model::DeleteSessionRequest& request) const;
 
  template <typename DeleteSessionRequestT = Model::DeleteSessionRequest>
  Model::DeleteSessionOutcomeCallable DeleteSessionCallable(const DeleteSessionRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::DeleteSession, request);
  }
 
  template <typename DeleteSessionRequestT = Model::DeleteSessionRequest>
  void DeleteSessionAsync(const DeleteSessionRequestT& request, const DeleteSessionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::DeleteSession, request, handler, context);
  }
 
  virtual Model::EndSessionOutcome EndSession(const Model::EndSessionRequest& request) const;
 
  template <typename EndSessionRequestT = Model::EndSessionRequest>
  Model::EndSessionOutcomeCallable EndSessionCallable(const EndSessionRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::EndSession, request);
  }
 
  template <typename EndSessionRequestT = Model::EndSessionRequest>
  void EndSessionAsync(const EndSessionRequestT& request, const EndSessionResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::EndSession, request, handler, context);
  }
 
  virtual Model::GenerateQueryOutcome GenerateQuery(const Model::GenerateQueryRequest& request) const;
 
  template <typename GenerateQueryRequestT = Model::GenerateQueryRequest>
  Model::GenerateQueryOutcomeCallable GenerateQueryCallable(const GenerateQueryRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::GenerateQuery, request);
  }
 
  template <typename GenerateQueryRequestT = Model::GenerateQueryRequest>
  void GenerateQueryAsync(const GenerateQueryRequestT& request, const GenerateQueryResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::GenerateQuery, request, handler, context);
  }
 
  virtual Model::GetAgentMemoryOutcome GetAgentMemory(const Model::GetAgentMemoryRequest& request) const;
 
  template <typename GetAgentMemoryRequestT = Model::GetAgentMemoryRequest>
  Model::GetAgentMemoryOutcomeCallable GetAgentMemoryCallable(const GetAgentMemoryRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::GetAgentMemory, request);
  }
 
  template <typename GetAgentMemoryRequestT = Model::GetAgentMemoryRequest>
  void GetAgentMemoryAsync(const GetAgentMemoryRequestT& request, const GetAgentMemoryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::GetAgentMemory, request, handler, context);
  }
 
  virtual Model::GetDocumentContentOutcome GetDocumentContent(const Model::GetDocumentContentRequest& request) const;
 
  template <typename GetDocumentContentRequestT = Model::GetDocumentContentRequest>
  Model::GetDocumentContentOutcomeCallable GetDocumentContentCallable(const GetDocumentContentRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::GetDocumentContent, request);
  }
 
  template <typename GetDocumentContentRequestT = Model::GetDocumentContentRequest>
  void GetDocumentContentAsync(const GetDocumentContentRequestT& request, const GetDocumentContentResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::GetDocumentContent, request, handler, context);
  }
 
  virtual Model::GetExecutionFlowSnapshotOutcome GetExecutionFlowSnapshot(const Model::GetExecutionFlowSnapshotRequest& request) const;
 
  template <typename GetExecutionFlowSnapshotRequestT = Model::GetExecutionFlowSnapshotRequest>
  Model::GetExecutionFlowSnapshotOutcomeCallable GetExecutionFlowSnapshotCallable(const GetExecutionFlowSnapshotRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::GetExecutionFlowSnapshot, request);
  }
 
  template <typename GetExecutionFlowSnapshotRequestT = Model::GetExecutionFlowSnapshotRequest>
  void GetExecutionFlowSnapshotAsync(const GetExecutionFlowSnapshotRequestT& request,
                                     const GetExecutionFlowSnapshotResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::GetExecutionFlowSnapshot, request, handler, context);
  }
 
  virtual Model::GetFlowExecutionOutcome GetFlowExecution(const Model::GetFlowExecutionRequest& request) const;
 
  template <typename GetFlowExecutionRequestT = Model::GetFlowExecutionRequest>
  Model::GetFlowExecutionOutcomeCallable GetFlowExecutionCallable(const GetFlowExecutionRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::GetFlowExecution, request);
  }
 
  template <typename GetFlowExecutionRequestT = Model::GetFlowExecutionRequest>
  void GetFlowExecutionAsync(const GetFlowExecutionRequestT& request, const GetFlowExecutionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::GetFlowExecution, request, handler, context);
  }
 
  virtual Model::GetInvocationStepOutcome GetInvocationStep(const Model::GetInvocationStepRequest& request) const;
 
  template <typename GetInvocationStepRequestT = Model::GetInvocationStepRequest>
  Model::GetInvocationStepOutcomeCallable GetInvocationStepCallable(const GetInvocationStepRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::GetInvocationStep, request);
  }
 
  template <typename GetInvocationStepRequestT = Model::GetInvocationStepRequest>
  void GetInvocationStepAsync(const GetInvocationStepRequestT& request, const GetInvocationStepResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::GetInvocationStep, request, handler, context);
  }
 
  virtual Model::GetSessionOutcome GetSession(const Model::GetSessionRequest& request) const;
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  Model::GetSessionOutcomeCallable GetSessionCallable(const GetSessionRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::GetSession, request);
  }
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  void GetSessionAsync(const GetSessionRequestT& request, const GetSessionResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::GetSession, request, handler, context);
  }
 
  virtual Model::InvokeAgentOutcome InvokeAgent(Model::InvokeAgentRequest& request) const;
 
  template <typename InvokeAgentRequestT = Model::InvokeAgentRequest>
  Model::InvokeAgentOutcomeCallable InvokeAgentCallable(InvokeAgentRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::InvokeAgent, request);
  }
 
  template <typename InvokeAgentRequestT = Model::InvokeAgentRequest>
  void InvokeAgentAsync(InvokeAgentRequestT& request, const InvokeAgentResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::InvokeAgent, request, handler, context);
  }
 
  virtual Model::InvokeFlowOutcome InvokeFlow(Model::InvokeFlowRequest& request) const;
 
  template <typename InvokeFlowRequestT = Model::InvokeFlowRequest>
  Model::InvokeFlowOutcomeCallable InvokeFlowCallable(InvokeFlowRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::InvokeFlow, request);
  }
 
  template <typename InvokeFlowRequestT = Model::InvokeFlowRequest>
  void InvokeFlowAsync(InvokeFlowRequestT& request, const InvokeFlowResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::InvokeFlow, request, handler, context);
  }
 
  virtual Model::InvokeInlineAgentOutcome InvokeInlineAgent(Model::InvokeInlineAgentRequest& request) const;
 
  template <typename InvokeInlineAgentRequestT = Model::InvokeInlineAgentRequest>
  Model::InvokeInlineAgentOutcomeCallable InvokeInlineAgentCallable(InvokeInlineAgentRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::InvokeInlineAgent, request);
  }
 
  template <typename InvokeInlineAgentRequestT = Model::InvokeInlineAgentRequest>
  void InvokeInlineAgentAsync(InvokeInlineAgentRequestT& request, const InvokeInlineAgentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::InvokeInlineAgent, request, handler, context);
  }
 
  virtual Model::ListFlowExecutionEventsOutcome ListFlowExecutionEvents(const Model::ListFlowExecutionEventsRequest& request) const;
 
  template <typename ListFlowExecutionEventsRequestT = Model::ListFlowExecutionEventsRequest>
  Model::ListFlowExecutionEventsOutcomeCallable ListFlowExecutionEventsCallable(const ListFlowExecutionEventsRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::ListFlowExecutionEvents, request);
  }
 
  template <typename ListFlowExecutionEventsRequestT = Model::ListFlowExecutionEventsRequest>
  void ListFlowExecutionEventsAsync(const ListFlowExecutionEventsRequestT& request,
                                    const ListFlowExecutionEventsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::ListFlowExecutionEvents, request, handler, context);
  }
 
  virtual Model::ListFlowExecutionsOutcome ListFlowExecutions(const Model::ListFlowExecutionsRequest& request) const;
 
  template <typename ListFlowExecutionsRequestT = Model::ListFlowExecutionsRequest>
  Model::ListFlowExecutionsOutcomeCallable ListFlowExecutionsCallable(const ListFlowExecutionsRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::ListFlowExecutions, request);
  }
 
  template <typename ListFlowExecutionsRequestT = Model::ListFlowExecutionsRequest>
  void ListFlowExecutionsAsync(const ListFlowExecutionsRequestT& request, const ListFlowExecutionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::ListFlowExecutions, request, handler, context);
  }
 
  virtual Model::ListInvocationStepsOutcome ListInvocationSteps(const Model::ListInvocationStepsRequest& request) const;
 
  template <typename ListInvocationStepsRequestT = Model::ListInvocationStepsRequest>
  Model::ListInvocationStepsOutcomeCallable ListInvocationStepsCallable(const ListInvocationStepsRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::ListInvocationSteps, request);
  }
 
  template <typename ListInvocationStepsRequestT = Model::ListInvocationStepsRequest>
  void ListInvocationStepsAsync(const ListInvocationStepsRequestT& request, const ListInvocationStepsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::ListInvocationSteps, request, handler, context);
  }
 
  virtual Model::ListInvocationsOutcome ListInvocations(const Model::ListInvocationsRequest& request) const;
 
  template <typename ListInvocationsRequestT = Model::ListInvocationsRequest>
  Model::ListInvocationsOutcomeCallable ListInvocationsCallable(const ListInvocationsRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::ListInvocations, request);
  }
 
  template <typename ListInvocationsRequestT = Model::ListInvocationsRequest>
  void ListInvocationsAsync(const ListInvocationsRequestT& request, const ListInvocationsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::ListInvocations, request, handler, context);
  }
 
  virtual Model::ListSessionsOutcome ListSessions(const Model::ListSessionsRequest& request = {}) const;
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  Model::ListSessionsOutcomeCallable ListSessionsCallable(const ListSessionsRequestT& request = {}) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::ListSessions, request);
  }
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  void ListSessionsAsync(const ListSessionsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListSessionsRequestT& request = {}) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::ListSessions, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::OptimizePromptOutcome OptimizePrompt(Model::OptimizePromptRequest& request) const;
 
  template <typename OptimizePromptRequestT = Model::OptimizePromptRequest>
  Model::OptimizePromptOutcomeCallable OptimizePromptCallable(OptimizePromptRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::OptimizePrompt, request);
  }
 
  template <typename OptimizePromptRequestT = Model::OptimizePromptRequest>
  void OptimizePromptAsync(OptimizePromptRequestT& request, const OptimizePromptResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::OptimizePrompt, request, handler, context);
  }
 
  virtual Model::PutInvocationStepOutcome PutInvocationStep(const Model::PutInvocationStepRequest& request) const;
 
  template <typename PutInvocationStepRequestT = Model::PutInvocationStepRequest>
  Model::PutInvocationStepOutcomeCallable PutInvocationStepCallable(const PutInvocationStepRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::PutInvocationStep, request);
  }
 
  template <typename PutInvocationStepRequestT = Model::PutInvocationStepRequest>
  void PutInvocationStepAsync(const PutInvocationStepRequestT& request, const PutInvocationStepResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::PutInvocationStep, request, handler, context);
  }
 
  virtual Model::RerankOutcome Rerank(const Model::RerankRequest& request) const;
 
  template <typename RerankRequestT = Model::RerankRequest>
  Model::RerankOutcomeCallable RerankCallable(const RerankRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::Rerank, request);
  }
 
  template <typename RerankRequestT = Model::RerankRequest>
  void RerankAsync(const RerankRequestT& request, const RerankResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::Rerank, request, handler, context);
  }
 
  virtual Model::RetrieveOutcome Retrieve(const Model::RetrieveRequest& request) const;
 
  template <typename RetrieveRequestT = Model::RetrieveRequest>
  Model::RetrieveOutcomeCallable RetrieveCallable(const RetrieveRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::Retrieve, request);
  }
 
  template <typename RetrieveRequestT = Model::RetrieveRequest>
  void RetrieveAsync(const RetrieveRequestT& request, const RetrieveResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::Retrieve, request, handler, context);
  }
 
  virtual Model::RetrieveAndGenerateOutcome RetrieveAndGenerate(const Model::RetrieveAndGenerateRequest& request) const;
 
  template <typename RetrieveAndGenerateRequestT = Model::RetrieveAndGenerateRequest>
  Model::RetrieveAndGenerateOutcomeCallable RetrieveAndGenerateCallable(const RetrieveAndGenerateRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::RetrieveAndGenerate, request);
  }
 
  template <typename RetrieveAndGenerateRequestT = Model::RetrieveAndGenerateRequest>
  void RetrieveAndGenerateAsync(const RetrieveAndGenerateRequestT& request, const RetrieveAndGenerateResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::RetrieveAndGenerate, request, handler, context);
  }
 
  virtual Model::RetrieveAndGenerateStreamOutcome RetrieveAndGenerateStream(Model::RetrieveAndGenerateStreamRequest& request) const;
 
  template <typename RetrieveAndGenerateStreamRequestT = Model::RetrieveAndGenerateStreamRequest>
  Model::RetrieveAndGenerateStreamOutcomeCallable RetrieveAndGenerateStreamCallable(RetrieveAndGenerateStreamRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::RetrieveAndGenerateStream, request);
  }
 
  template <typename RetrieveAndGenerateStreamRequestT = Model::RetrieveAndGenerateStreamRequest>
  void RetrieveAndGenerateStreamAsync(RetrieveAndGenerateStreamRequestT& request,
                                      const RetrieveAndGenerateStreamResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::RetrieveAndGenerateStream, request, handler, context);
  }
 
  virtual Model::StartFlowExecutionOutcome StartFlowExecution(const Model::StartFlowExecutionRequest& request) const;
 
  template <typename StartFlowExecutionRequestT = Model::StartFlowExecutionRequest>
  Model::StartFlowExecutionOutcomeCallable StartFlowExecutionCallable(const StartFlowExecutionRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::StartFlowExecution, request);
  }
 
  template <typename StartFlowExecutionRequestT = Model::StartFlowExecutionRequest>
  void StartFlowExecutionAsync(const StartFlowExecutionRequestT& request, const StartFlowExecutionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::StartFlowExecution, request, handler, context);
  }
 
  virtual Model::StopFlowExecutionOutcome StopFlowExecution(const Model::StopFlowExecutionRequest& request) const;
 
  template <typename StopFlowExecutionRequestT = Model::StopFlowExecutionRequest>
  Model::StopFlowExecutionOutcomeCallable StopFlowExecutionCallable(const StopFlowExecutionRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::StopFlowExecution, request);
  }
 
  template <typename StopFlowExecutionRequestT = Model::StopFlowExecutionRequest>
  void StopFlowExecutionAsync(const StopFlowExecutionRequestT& request, const StopFlowExecutionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::StopFlowExecution, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateSessionOutcome UpdateSession(const Model::UpdateSessionRequest& request) const;
 
  template <typename UpdateSessionRequestT = Model::UpdateSessionRequest>
  Model::UpdateSessionOutcomeCallable UpdateSessionCallable(const UpdateSessionRequestT& request) const {
    return SubmitCallable(&BedrockAgentRuntimeClient::UpdateSession, request);
  }
 
  template <typename UpdateSessionRequestT = Model::UpdateSessionRequest>
  void UpdateSessionAsync(const UpdateSessionRequestT& request, const UpdateSessionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentRuntimeClient::UpdateSession, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<BedrockAgentRuntimeEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BedrockAgentRuntimeClient>;
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>, BedrockAgentRuntimeError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::AWSEndpoint&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
};
 
}  // namespace BedrockAgentRuntime
}  // namespace Aws