BedrockAgentRuntimeClient.h

 
#pragma once
#include <aws/bedrock-agent-runtime/BedrockAgentRuntime_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/bedrock-agent-runtime/BedrockAgentRuntimeServiceClientModel.h>
 
namespace Aws
{
namespace BedrockAgentRuntime
{
  class AWS_BEDROCKAGENTRUNTIME_API BedrockAgentRuntimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<BedrockAgentRuntimeClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BedrockAgentRuntimeEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BedrockAgentRuntimeClient>;
      void init(const BedrockAgentRuntimeClientConfiguration& clientConfiguration);
 
      BedrockAgentRuntimeClientConfiguration m_clientConfiguration;
      std::shared_ptr<BedrockAgentRuntimeEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace BedrockAgentRuntime
} // namespace Aws