BedrockAgentClient.h

 
#pragma once
#include <aws/bedrock-agent/BedrockAgent_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/BedrockAgentServiceClientModel.h>
 
namespace Aws
{
namespace BedrockAgent
{
  class AWS_BEDROCKAGENT_API BedrockAgentClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<BedrockAgentClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef BedrockAgentClientConfiguration ClientConfigurationType;
      typedef BedrockAgentEndpointProvider EndpointProviderType;
 
        BedrockAgentClient(const Aws::BedrockAgent::BedrockAgentClientConfiguration& clientConfiguration = Aws::BedrockAgent::BedrockAgentClientConfiguration(),
                           std::shared_ptr<BedrockAgentEndpointProviderBase> endpointProvider = nullptr);
 
        BedrockAgentClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<BedrockAgentEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::BedrockAgent::BedrockAgentClientConfiguration& clientConfiguration = Aws::BedrockAgent::BedrockAgentClientConfiguration());
 
        BedrockAgentClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<BedrockAgentEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::BedrockAgent::BedrockAgentClientConfiguration& clientConfiguration = Aws::BedrockAgent::BedrockAgentClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        BedrockAgentClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BedrockAgentClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BedrockAgentClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~BedrockAgentClient();
 
        virtual Model::AssociateAgentCollaboratorOutcome AssociateAgentCollaborator(const Model::AssociateAgentCollaboratorRequest& request) const;
 
        template<typename AssociateAgentCollaboratorRequestT = Model::AssociateAgentCollaboratorRequest>
        Model::AssociateAgentCollaboratorOutcomeCallable AssociateAgentCollaboratorCallable(const AssociateAgentCollaboratorRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::AssociateAgentCollaborator, request);
        }
 
        template<typename AssociateAgentCollaboratorRequestT = Model::AssociateAgentCollaboratorRequest>
        void AssociateAgentCollaboratorAsync(const AssociateAgentCollaboratorRequestT& request, const AssociateAgentCollaboratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::AssociateAgentCollaborator, request, handler, context);
        }
 
        virtual Model::AssociateAgentKnowledgeBaseOutcome AssociateAgentKnowledgeBase(const Model::AssociateAgentKnowledgeBaseRequest& request) const;
 
        template<typename AssociateAgentKnowledgeBaseRequestT = Model::AssociateAgentKnowledgeBaseRequest>
        Model::AssociateAgentKnowledgeBaseOutcomeCallable AssociateAgentKnowledgeBaseCallable(const AssociateAgentKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::AssociateAgentKnowledgeBase, request);
        }
 
        template<typename AssociateAgentKnowledgeBaseRequestT = Model::AssociateAgentKnowledgeBaseRequest>
        void AssociateAgentKnowledgeBaseAsync(const AssociateAgentKnowledgeBaseRequestT& request, const AssociateAgentKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::AssociateAgentKnowledgeBase, request, handler, context);
        }
 
        virtual Model::CreateAgentOutcome CreateAgent(const Model::CreateAgentRequest& request) const;
 
        template<typename CreateAgentRequestT = Model::CreateAgentRequest>
        Model::CreateAgentOutcomeCallable CreateAgentCallable(const CreateAgentRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreateAgent, request);
        }
 
        template<typename CreateAgentRequestT = Model::CreateAgentRequest>
        void CreateAgentAsync(const CreateAgentRequestT& request, const CreateAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreateAgent, request, handler, context);
        }
 
        virtual Model::CreateAgentActionGroupOutcome CreateAgentActionGroup(const Model::CreateAgentActionGroupRequest& request) const;
 
        template<typename CreateAgentActionGroupRequestT = Model::CreateAgentActionGroupRequest>
        Model::CreateAgentActionGroupOutcomeCallable CreateAgentActionGroupCallable(const CreateAgentActionGroupRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreateAgentActionGroup, request);
        }
 
        template<typename CreateAgentActionGroupRequestT = Model::CreateAgentActionGroupRequest>
        void CreateAgentActionGroupAsync(const CreateAgentActionGroupRequestT& request, const CreateAgentActionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreateAgentActionGroup, request, handler, context);
        }
 
        virtual Model::CreateAgentAliasOutcome CreateAgentAlias(const Model::CreateAgentAliasRequest& request) const;
 
        template<typename CreateAgentAliasRequestT = Model::CreateAgentAliasRequest>
        Model::CreateAgentAliasOutcomeCallable CreateAgentAliasCallable(const CreateAgentAliasRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreateAgentAlias, request);
        }
 
        template<typename CreateAgentAliasRequestT = Model::CreateAgentAliasRequest>
        void CreateAgentAliasAsync(const CreateAgentAliasRequestT& request, const CreateAgentAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreateAgentAlias, request, handler, context);
        }
 
        virtual Model::CreateDataSourceOutcome CreateDataSource(const Model::CreateDataSourceRequest& request) const;
 
        template<typename CreateDataSourceRequestT = Model::CreateDataSourceRequest>
        Model::CreateDataSourceOutcomeCallable CreateDataSourceCallable(const CreateDataSourceRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreateDataSource, request);
        }
 
        template<typename CreateDataSourceRequestT = Model::CreateDataSourceRequest>
        void CreateDataSourceAsync(const CreateDataSourceRequestT& request, const CreateDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreateDataSource, request, handler, context);
        }
 
        virtual Model::CreateFlowOutcome CreateFlow(const Model::CreateFlowRequest& request) const;
 
        template<typename CreateFlowRequestT = Model::CreateFlowRequest>
        Model::CreateFlowOutcomeCallable CreateFlowCallable(const CreateFlowRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreateFlow, request);
        }
 
        template<typename CreateFlowRequestT = Model::CreateFlowRequest>
        void CreateFlowAsync(const CreateFlowRequestT& request, const CreateFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreateFlow, request, handler, context);
        }
 
        virtual Model::CreateFlowAliasOutcome CreateFlowAlias(const Model::CreateFlowAliasRequest& request) const;
 
        template<typename CreateFlowAliasRequestT = Model::CreateFlowAliasRequest>
        Model::CreateFlowAliasOutcomeCallable CreateFlowAliasCallable(const CreateFlowAliasRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreateFlowAlias, request);
        }
 
        template<typename CreateFlowAliasRequestT = Model::CreateFlowAliasRequest>
        void CreateFlowAliasAsync(const CreateFlowAliasRequestT& request, const CreateFlowAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreateFlowAlias, request, handler, context);
        }
 
        virtual Model::CreateFlowVersionOutcome CreateFlowVersion(const Model::CreateFlowVersionRequest& request) const;
 
        template<typename CreateFlowVersionRequestT = Model::CreateFlowVersionRequest>
        Model::CreateFlowVersionOutcomeCallable CreateFlowVersionCallable(const CreateFlowVersionRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreateFlowVersion, request);
        }
 
        template<typename CreateFlowVersionRequestT = Model::CreateFlowVersionRequest>
        void CreateFlowVersionAsync(const CreateFlowVersionRequestT& request, const CreateFlowVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreateFlowVersion, request, handler, context);
        }
 
        virtual Model::CreateKnowledgeBaseOutcome CreateKnowledgeBase(const Model::CreateKnowledgeBaseRequest& request) const;
 
        template<typename CreateKnowledgeBaseRequestT = Model::CreateKnowledgeBaseRequest>
        Model::CreateKnowledgeBaseOutcomeCallable CreateKnowledgeBaseCallable(const CreateKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreateKnowledgeBase, request);
        }
 
        template<typename CreateKnowledgeBaseRequestT = Model::CreateKnowledgeBaseRequest>
        void CreateKnowledgeBaseAsync(const CreateKnowledgeBaseRequestT& request, const CreateKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreateKnowledgeBase, request, handler, context);
        }
 
        virtual Model::CreatePromptOutcome CreatePrompt(const Model::CreatePromptRequest& request) const;
 
        template<typename CreatePromptRequestT = Model::CreatePromptRequest>
        Model::CreatePromptOutcomeCallable CreatePromptCallable(const CreatePromptRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreatePrompt, request);
        }
 
        template<typename CreatePromptRequestT = Model::CreatePromptRequest>
        void CreatePromptAsync(const CreatePromptRequestT& request, const CreatePromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreatePrompt, request, handler, context);
        }
 
        virtual Model::CreatePromptVersionOutcome CreatePromptVersion(const Model::CreatePromptVersionRequest& request) const;
 
        template<typename CreatePromptVersionRequestT = Model::CreatePromptVersionRequest>
        Model::CreatePromptVersionOutcomeCallable CreatePromptVersionCallable(const CreatePromptVersionRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::CreatePromptVersion, request);
        }
 
        template<typename CreatePromptVersionRequestT = Model::CreatePromptVersionRequest>
        void CreatePromptVersionAsync(const CreatePromptVersionRequestT& request, const CreatePromptVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::CreatePromptVersion, request, handler, context);
        }
 
        virtual Model::DeleteAgentOutcome DeleteAgent(const Model::DeleteAgentRequest& request) const;
 
        template<typename DeleteAgentRequestT = Model::DeleteAgentRequest>
        Model::DeleteAgentOutcomeCallable DeleteAgentCallable(const DeleteAgentRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteAgent, request);
        }
 
        template<typename DeleteAgentRequestT = Model::DeleteAgentRequest>
        void DeleteAgentAsync(const DeleteAgentRequestT& request, const DeleteAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteAgent, request, handler, context);
        }
 
        virtual Model::DeleteAgentActionGroupOutcome DeleteAgentActionGroup(const Model::DeleteAgentActionGroupRequest& request) const;
 
        template<typename DeleteAgentActionGroupRequestT = Model::DeleteAgentActionGroupRequest>
        Model::DeleteAgentActionGroupOutcomeCallable DeleteAgentActionGroupCallable(const DeleteAgentActionGroupRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteAgentActionGroup, request);
        }
 
        template<typename DeleteAgentActionGroupRequestT = Model::DeleteAgentActionGroupRequest>
        void DeleteAgentActionGroupAsync(const DeleteAgentActionGroupRequestT& request, const DeleteAgentActionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteAgentActionGroup, request, handler, context);
        }
 
        virtual Model::DeleteAgentAliasOutcome DeleteAgentAlias(const Model::DeleteAgentAliasRequest& request) const;
 
        template<typename DeleteAgentAliasRequestT = Model::DeleteAgentAliasRequest>
        Model::DeleteAgentAliasOutcomeCallable DeleteAgentAliasCallable(const DeleteAgentAliasRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteAgentAlias, request);
        }
 
        template<typename DeleteAgentAliasRequestT = Model::DeleteAgentAliasRequest>
        void DeleteAgentAliasAsync(const DeleteAgentAliasRequestT& request, const DeleteAgentAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteAgentAlias, request, handler, context);
        }
 
        virtual Model::DeleteAgentVersionOutcome DeleteAgentVersion(const Model::DeleteAgentVersionRequest& request) const;
 
        template<typename DeleteAgentVersionRequestT = Model::DeleteAgentVersionRequest>
        Model::DeleteAgentVersionOutcomeCallable DeleteAgentVersionCallable(const DeleteAgentVersionRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteAgentVersion, request);
        }
 
        template<typename DeleteAgentVersionRequestT = Model::DeleteAgentVersionRequest>
        void DeleteAgentVersionAsync(const DeleteAgentVersionRequestT& request, const DeleteAgentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteAgentVersion, request, handler, context);
        }
 
        virtual Model::DeleteDataSourceOutcome DeleteDataSource(const Model::DeleteDataSourceRequest& request) const;
 
        template<typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
        Model::DeleteDataSourceOutcomeCallable DeleteDataSourceCallable(const DeleteDataSourceRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteDataSource, request);
        }
 
        template<typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
        void DeleteDataSourceAsync(const DeleteDataSourceRequestT& request, const DeleteDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteDataSource, request, handler, context);
        }
 
        virtual Model::DeleteFlowOutcome DeleteFlow(const Model::DeleteFlowRequest& request) const;
 
        template<typename DeleteFlowRequestT = Model::DeleteFlowRequest>
        Model::DeleteFlowOutcomeCallable DeleteFlowCallable(const DeleteFlowRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteFlow, request);
        }
 
        template<typename DeleteFlowRequestT = Model::DeleteFlowRequest>
        void DeleteFlowAsync(const DeleteFlowRequestT& request, const DeleteFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteFlow, request, handler, context);
        }
 
        virtual Model::DeleteFlowAliasOutcome DeleteFlowAlias(const Model::DeleteFlowAliasRequest& request) const;
 
        template<typename DeleteFlowAliasRequestT = Model::DeleteFlowAliasRequest>
        Model::DeleteFlowAliasOutcomeCallable DeleteFlowAliasCallable(const DeleteFlowAliasRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteFlowAlias, request);
        }
 
        template<typename DeleteFlowAliasRequestT = Model::DeleteFlowAliasRequest>
        void DeleteFlowAliasAsync(const DeleteFlowAliasRequestT& request, const DeleteFlowAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteFlowAlias, request, handler, context);
        }
 
        virtual Model::DeleteFlowVersionOutcome DeleteFlowVersion(const Model::DeleteFlowVersionRequest& request) const;
 
        template<typename DeleteFlowVersionRequestT = Model::DeleteFlowVersionRequest>
        Model::DeleteFlowVersionOutcomeCallable DeleteFlowVersionCallable(const DeleteFlowVersionRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteFlowVersion, request);
        }
 
        template<typename DeleteFlowVersionRequestT = Model::DeleteFlowVersionRequest>
        void DeleteFlowVersionAsync(const DeleteFlowVersionRequestT& request, const DeleteFlowVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteFlowVersion, request, handler, context);
        }
 
        virtual Model::DeleteKnowledgeBaseOutcome DeleteKnowledgeBase(const Model::DeleteKnowledgeBaseRequest& request) const;
 
        template<typename DeleteKnowledgeBaseRequestT = Model::DeleteKnowledgeBaseRequest>
        Model::DeleteKnowledgeBaseOutcomeCallable DeleteKnowledgeBaseCallable(const DeleteKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteKnowledgeBase, request);
        }
 
        template<typename DeleteKnowledgeBaseRequestT = Model::DeleteKnowledgeBaseRequest>
        void DeleteKnowledgeBaseAsync(const DeleteKnowledgeBaseRequestT& request, const DeleteKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteKnowledgeBase, request, handler, context);
        }
 
        virtual Model::DeleteKnowledgeBaseDocumentsOutcome DeleteKnowledgeBaseDocuments(const Model::DeleteKnowledgeBaseDocumentsRequest& request) const;
 
        template<typename DeleteKnowledgeBaseDocumentsRequestT = Model::DeleteKnowledgeBaseDocumentsRequest>
        Model::DeleteKnowledgeBaseDocumentsOutcomeCallable DeleteKnowledgeBaseDocumentsCallable(const DeleteKnowledgeBaseDocumentsRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeleteKnowledgeBaseDocuments, request);
        }
 
        template<typename DeleteKnowledgeBaseDocumentsRequestT = Model::DeleteKnowledgeBaseDocumentsRequest>
        void DeleteKnowledgeBaseDocumentsAsync(const DeleteKnowledgeBaseDocumentsRequestT& request, const DeleteKnowledgeBaseDocumentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeleteKnowledgeBaseDocuments, request, handler, context);
        }
 
        virtual Model::DeletePromptOutcome DeletePrompt(const Model::DeletePromptRequest& request) const;
 
        template<typename DeletePromptRequestT = Model::DeletePromptRequest>
        Model::DeletePromptOutcomeCallable DeletePromptCallable(const DeletePromptRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DeletePrompt, request);
        }
 
        template<typename DeletePromptRequestT = Model::DeletePromptRequest>
        void DeletePromptAsync(const DeletePromptRequestT& request, const DeletePromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DeletePrompt, request, handler, context);
        }
 
        virtual Model::DisassociateAgentCollaboratorOutcome DisassociateAgentCollaborator(const Model::DisassociateAgentCollaboratorRequest& request) const;
 
        template<typename DisassociateAgentCollaboratorRequestT = Model::DisassociateAgentCollaboratorRequest>
        Model::DisassociateAgentCollaboratorOutcomeCallable DisassociateAgentCollaboratorCallable(const DisassociateAgentCollaboratorRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DisassociateAgentCollaborator, request);
        }
 
        template<typename DisassociateAgentCollaboratorRequestT = Model::DisassociateAgentCollaboratorRequest>
        void DisassociateAgentCollaboratorAsync(const DisassociateAgentCollaboratorRequestT& request, const DisassociateAgentCollaboratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DisassociateAgentCollaborator, request, handler, context);
        }
 
        virtual Model::DisassociateAgentKnowledgeBaseOutcome DisassociateAgentKnowledgeBase(const Model::DisassociateAgentKnowledgeBaseRequest& request) const;
 
        template<typename DisassociateAgentKnowledgeBaseRequestT = Model::DisassociateAgentKnowledgeBaseRequest>
        Model::DisassociateAgentKnowledgeBaseOutcomeCallable DisassociateAgentKnowledgeBaseCallable(const DisassociateAgentKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::DisassociateAgentKnowledgeBase, request);
        }
 
        template<typename DisassociateAgentKnowledgeBaseRequestT = Model::DisassociateAgentKnowledgeBaseRequest>
        void DisassociateAgentKnowledgeBaseAsync(const DisassociateAgentKnowledgeBaseRequestT& request, const DisassociateAgentKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::DisassociateAgentKnowledgeBase, request, handler, context);
        }
 
        virtual Model::GetAgentOutcome GetAgent(const Model::GetAgentRequest& request) const;
 
        template<typename GetAgentRequestT = Model::GetAgentRequest>
        Model::GetAgentOutcomeCallable GetAgentCallable(const GetAgentRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetAgent, request);
        }
 
        template<typename GetAgentRequestT = Model::GetAgentRequest>
        void GetAgentAsync(const GetAgentRequestT& request, const GetAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetAgent, request, handler, context);
        }
 
        virtual Model::GetAgentActionGroupOutcome GetAgentActionGroup(const Model::GetAgentActionGroupRequest& request) const;
 
        template<typename GetAgentActionGroupRequestT = Model::GetAgentActionGroupRequest>
        Model::GetAgentActionGroupOutcomeCallable GetAgentActionGroupCallable(const GetAgentActionGroupRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetAgentActionGroup, request);
        }
 
        template<typename GetAgentActionGroupRequestT = Model::GetAgentActionGroupRequest>
        void GetAgentActionGroupAsync(const GetAgentActionGroupRequestT& request, const GetAgentActionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetAgentActionGroup, request, handler, context);
        }
 
        virtual Model::GetAgentAliasOutcome GetAgentAlias(const Model::GetAgentAliasRequest& request) const;
 
        template<typename GetAgentAliasRequestT = Model::GetAgentAliasRequest>
        Model::GetAgentAliasOutcomeCallable GetAgentAliasCallable(const GetAgentAliasRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetAgentAlias, request);
        }
 
        template<typename GetAgentAliasRequestT = Model::GetAgentAliasRequest>
        void GetAgentAliasAsync(const GetAgentAliasRequestT& request, const GetAgentAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetAgentAlias, request, handler, context);
        }
 
        virtual Model::GetAgentCollaboratorOutcome GetAgentCollaborator(const Model::GetAgentCollaboratorRequest& request) const;
 
        template<typename GetAgentCollaboratorRequestT = Model::GetAgentCollaboratorRequest>
        Model::GetAgentCollaboratorOutcomeCallable GetAgentCollaboratorCallable(const GetAgentCollaboratorRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetAgentCollaborator, request);
        }
 
        template<typename GetAgentCollaboratorRequestT = Model::GetAgentCollaboratorRequest>
        void GetAgentCollaboratorAsync(const GetAgentCollaboratorRequestT& request, const GetAgentCollaboratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetAgentCollaborator, request, handler, context);
        }
 
        virtual Model::GetAgentKnowledgeBaseOutcome GetAgentKnowledgeBase(const Model::GetAgentKnowledgeBaseRequest& request) const;
 
        template<typename GetAgentKnowledgeBaseRequestT = Model::GetAgentKnowledgeBaseRequest>
        Model::GetAgentKnowledgeBaseOutcomeCallable GetAgentKnowledgeBaseCallable(const GetAgentKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetAgentKnowledgeBase, request);
        }
 
        template<typename GetAgentKnowledgeBaseRequestT = Model::GetAgentKnowledgeBaseRequest>
        void GetAgentKnowledgeBaseAsync(const GetAgentKnowledgeBaseRequestT& request, const GetAgentKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetAgentKnowledgeBase, request, handler, context);
        }
 
        virtual Model::GetAgentVersionOutcome GetAgentVersion(const Model::GetAgentVersionRequest& request) const;
 
        template<typename GetAgentVersionRequestT = Model::GetAgentVersionRequest>
        Model::GetAgentVersionOutcomeCallable GetAgentVersionCallable(const GetAgentVersionRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetAgentVersion, request);
        }
 
        template<typename GetAgentVersionRequestT = Model::GetAgentVersionRequest>
        void GetAgentVersionAsync(const GetAgentVersionRequestT& request, const GetAgentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetAgentVersion, request, handler, context);
        }
 
        virtual Model::GetDataSourceOutcome GetDataSource(const Model::GetDataSourceRequest& request) const;
 
        template<typename GetDataSourceRequestT = Model::GetDataSourceRequest>
        Model::GetDataSourceOutcomeCallable GetDataSourceCallable(const GetDataSourceRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetDataSource, request);
        }
 
        template<typename GetDataSourceRequestT = Model::GetDataSourceRequest>
        void GetDataSourceAsync(const GetDataSourceRequestT& request, const GetDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetDataSource, request, handler, context);
        }
 
        virtual Model::GetFlowOutcome GetFlow(const Model::GetFlowRequest& request) const;
 
        template<typename GetFlowRequestT = Model::GetFlowRequest>
        Model::GetFlowOutcomeCallable GetFlowCallable(const GetFlowRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetFlow, request);
        }
 
        template<typename GetFlowRequestT = Model::GetFlowRequest>
        void GetFlowAsync(const GetFlowRequestT& request, const GetFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetFlow, request, handler, context);
        }
 
        virtual Model::GetFlowAliasOutcome GetFlowAlias(const Model::GetFlowAliasRequest& request) const;
 
        template<typename GetFlowAliasRequestT = Model::GetFlowAliasRequest>
        Model::GetFlowAliasOutcomeCallable GetFlowAliasCallable(const GetFlowAliasRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetFlowAlias, request);
        }
 
        template<typename GetFlowAliasRequestT = Model::GetFlowAliasRequest>
        void GetFlowAliasAsync(const GetFlowAliasRequestT& request, const GetFlowAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetFlowAlias, request, handler, context);
        }
 
        virtual Model::GetFlowVersionOutcome GetFlowVersion(const Model::GetFlowVersionRequest& request) const;
 
        template<typename GetFlowVersionRequestT = Model::GetFlowVersionRequest>
        Model::GetFlowVersionOutcomeCallable GetFlowVersionCallable(const GetFlowVersionRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetFlowVersion, request);
        }
 
        template<typename GetFlowVersionRequestT = Model::GetFlowVersionRequest>
        void GetFlowVersionAsync(const GetFlowVersionRequestT& request, const GetFlowVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetFlowVersion, request, handler, context);
        }
 
        virtual Model::GetIngestionJobOutcome GetIngestionJob(const Model::GetIngestionJobRequest& request) const;
 
        template<typename GetIngestionJobRequestT = Model::GetIngestionJobRequest>
        Model::GetIngestionJobOutcomeCallable GetIngestionJobCallable(const GetIngestionJobRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetIngestionJob, request);
        }
 
        template<typename GetIngestionJobRequestT = Model::GetIngestionJobRequest>
        void GetIngestionJobAsync(const GetIngestionJobRequestT& request, const GetIngestionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetIngestionJob, request, handler, context);
        }
 
        virtual Model::GetKnowledgeBaseOutcome GetKnowledgeBase(const Model::GetKnowledgeBaseRequest& request) const;
 
        template<typename GetKnowledgeBaseRequestT = Model::GetKnowledgeBaseRequest>
        Model::GetKnowledgeBaseOutcomeCallable GetKnowledgeBaseCallable(const GetKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetKnowledgeBase, request);
        }
 
        template<typename GetKnowledgeBaseRequestT = Model::GetKnowledgeBaseRequest>
        void GetKnowledgeBaseAsync(const GetKnowledgeBaseRequestT& request, const GetKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetKnowledgeBase, request, handler, context);
        }
 
        virtual Model::GetKnowledgeBaseDocumentsOutcome GetKnowledgeBaseDocuments(const Model::GetKnowledgeBaseDocumentsRequest& request) const;
 
        template<typename GetKnowledgeBaseDocumentsRequestT = Model::GetKnowledgeBaseDocumentsRequest>
        Model::GetKnowledgeBaseDocumentsOutcomeCallable GetKnowledgeBaseDocumentsCallable(const GetKnowledgeBaseDocumentsRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetKnowledgeBaseDocuments, request);
        }
 
        template<typename GetKnowledgeBaseDocumentsRequestT = Model::GetKnowledgeBaseDocumentsRequest>
        void GetKnowledgeBaseDocumentsAsync(const GetKnowledgeBaseDocumentsRequestT& request, const GetKnowledgeBaseDocumentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetKnowledgeBaseDocuments, request, handler, context);
        }
 
        virtual Model::GetPromptOutcome GetPrompt(const Model::GetPromptRequest& request) const;
 
        template<typename GetPromptRequestT = Model::GetPromptRequest>
        Model::GetPromptOutcomeCallable GetPromptCallable(const GetPromptRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::GetPrompt, request);
        }
 
        template<typename GetPromptRequestT = Model::GetPromptRequest>
        void GetPromptAsync(const GetPromptRequestT& request, const GetPromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::GetPrompt, request, handler, context);
        }
 
        virtual Model::IngestKnowledgeBaseDocumentsOutcome IngestKnowledgeBaseDocuments(const Model::IngestKnowledgeBaseDocumentsRequest& request) const;
 
        template<typename IngestKnowledgeBaseDocumentsRequestT = Model::IngestKnowledgeBaseDocumentsRequest>
        Model::IngestKnowledgeBaseDocumentsOutcomeCallable IngestKnowledgeBaseDocumentsCallable(const IngestKnowledgeBaseDocumentsRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::IngestKnowledgeBaseDocuments, request);
        }
 
        template<typename IngestKnowledgeBaseDocumentsRequestT = Model::IngestKnowledgeBaseDocumentsRequest>
        void IngestKnowledgeBaseDocumentsAsync(const IngestKnowledgeBaseDocumentsRequestT& request, const IngestKnowledgeBaseDocumentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::IngestKnowledgeBaseDocuments, request, handler, context);
        }
 
        virtual Model::ListAgentActionGroupsOutcome ListAgentActionGroups(const Model::ListAgentActionGroupsRequest& request) const;
 
        template<typename ListAgentActionGroupsRequestT = Model::ListAgentActionGroupsRequest>
        Model::ListAgentActionGroupsOutcomeCallable ListAgentActionGroupsCallable(const ListAgentActionGroupsRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListAgentActionGroups, request);
        }
 
        template<typename ListAgentActionGroupsRequestT = Model::ListAgentActionGroupsRequest>
        void ListAgentActionGroupsAsync(const ListAgentActionGroupsRequestT& request, const ListAgentActionGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListAgentActionGroups, request, handler, context);
        }
 
        virtual Model::ListAgentAliasesOutcome ListAgentAliases(const Model::ListAgentAliasesRequest& request) const;
 
        template<typename ListAgentAliasesRequestT = Model::ListAgentAliasesRequest>
        Model::ListAgentAliasesOutcomeCallable ListAgentAliasesCallable(const ListAgentAliasesRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListAgentAliases, request);
        }
 
        template<typename ListAgentAliasesRequestT = Model::ListAgentAliasesRequest>
        void ListAgentAliasesAsync(const ListAgentAliasesRequestT& request, const ListAgentAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListAgentAliases, request, handler, context);
        }
 
        virtual Model::ListAgentCollaboratorsOutcome ListAgentCollaborators(const Model::ListAgentCollaboratorsRequest& request) const;
 
        template<typename ListAgentCollaboratorsRequestT = Model::ListAgentCollaboratorsRequest>
        Model::ListAgentCollaboratorsOutcomeCallable ListAgentCollaboratorsCallable(const ListAgentCollaboratorsRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListAgentCollaborators, request);
        }
 
        template<typename ListAgentCollaboratorsRequestT = Model::ListAgentCollaboratorsRequest>
        void ListAgentCollaboratorsAsync(const ListAgentCollaboratorsRequestT& request, const ListAgentCollaboratorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListAgentCollaborators, request, handler, context);
        }
 
        virtual Model::ListAgentKnowledgeBasesOutcome ListAgentKnowledgeBases(const Model::ListAgentKnowledgeBasesRequest& request) const;
 
        template<typename ListAgentKnowledgeBasesRequestT = Model::ListAgentKnowledgeBasesRequest>
        Model::ListAgentKnowledgeBasesOutcomeCallable ListAgentKnowledgeBasesCallable(const ListAgentKnowledgeBasesRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListAgentKnowledgeBases, request);
        }
 
        template<typename ListAgentKnowledgeBasesRequestT = Model::ListAgentKnowledgeBasesRequest>
        void ListAgentKnowledgeBasesAsync(const ListAgentKnowledgeBasesRequestT& request, const ListAgentKnowledgeBasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListAgentKnowledgeBases, request, handler, context);
        }
 
        virtual Model::ListAgentVersionsOutcome ListAgentVersions(const Model::ListAgentVersionsRequest& request) const;
 
        template<typename ListAgentVersionsRequestT = Model::ListAgentVersionsRequest>
        Model::ListAgentVersionsOutcomeCallable ListAgentVersionsCallable(const ListAgentVersionsRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListAgentVersions, request);
        }
 
        template<typename ListAgentVersionsRequestT = Model::ListAgentVersionsRequest>
        void ListAgentVersionsAsync(const ListAgentVersionsRequestT& request, const ListAgentVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListAgentVersions, request, handler, context);
        }
 
        virtual Model::ListAgentsOutcome ListAgents(const Model::ListAgentsRequest& request = {}) const;
 
        template<typename ListAgentsRequestT = Model::ListAgentsRequest>
        Model::ListAgentsOutcomeCallable ListAgentsCallable(const ListAgentsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockAgentClient::ListAgents, request);
        }
 
        template<typename ListAgentsRequestT = Model::ListAgentsRequest>
        void ListAgentsAsync(const ListAgentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAgentsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockAgentClient::ListAgents, request, handler, context);
        }
 
        virtual Model::ListDataSourcesOutcome ListDataSources(const Model::ListDataSourcesRequest& request) const;
 
        template<typename ListDataSourcesRequestT = Model::ListDataSourcesRequest>
        Model::ListDataSourcesOutcomeCallable ListDataSourcesCallable(const ListDataSourcesRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListDataSources, request);
        }
 
        template<typename ListDataSourcesRequestT = Model::ListDataSourcesRequest>
        void ListDataSourcesAsync(const ListDataSourcesRequestT& request, const ListDataSourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListDataSources, request, handler, context);
        }
 
        virtual Model::ListFlowAliasesOutcome ListFlowAliases(const Model::ListFlowAliasesRequest& request) const;
 
        template<typename ListFlowAliasesRequestT = Model::ListFlowAliasesRequest>
        Model::ListFlowAliasesOutcomeCallable ListFlowAliasesCallable(const ListFlowAliasesRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListFlowAliases, request);
        }
 
        template<typename ListFlowAliasesRequestT = Model::ListFlowAliasesRequest>
        void ListFlowAliasesAsync(const ListFlowAliasesRequestT& request, const ListFlowAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListFlowAliases, request, handler, context);
        }
 
        virtual Model::ListFlowVersionsOutcome ListFlowVersions(const Model::ListFlowVersionsRequest& request) const;
 
        template<typename ListFlowVersionsRequestT = Model::ListFlowVersionsRequest>
        Model::ListFlowVersionsOutcomeCallable ListFlowVersionsCallable(const ListFlowVersionsRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListFlowVersions, request);
        }
 
        template<typename ListFlowVersionsRequestT = Model::ListFlowVersionsRequest>
        void ListFlowVersionsAsync(const ListFlowVersionsRequestT& request, const ListFlowVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListFlowVersions, request, handler, context);
        }
 
        virtual Model::ListFlowsOutcome ListFlows(const Model::ListFlowsRequest& request = {}) const;
 
        template<typename ListFlowsRequestT = Model::ListFlowsRequest>
        Model::ListFlowsOutcomeCallable ListFlowsCallable(const ListFlowsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockAgentClient::ListFlows, request);
        }
 
        template<typename ListFlowsRequestT = Model::ListFlowsRequest>
        void ListFlowsAsync(const ListFlowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFlowsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockAgentClient::ListFlows, request, handler, context);
        }
 
        virtual Model::ListIngestionJobsOutcome ListIngestionJobs(const Model::ListIngestionJobsRequest& request) const;
 
        template<typename ListIngestionJobsRequestT = Model::ListIngestionJobsRequest>
        Model::ListIngestionJobsOutcomeCallable ListIngestionJobsCallable(const ListIngestionJobsRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListIngestionJobs, request);
        }
 
        template<typename ListIngestionJobsRequestT = Model::ListIngestionJobsRequest>
        void ListIngestionJobsAsync(const ListIngestionJobsRequestT& request, const ListIngestionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListIngestionJobs, request, handler, context);
        }
 
        virtual Model::ListKnowledgeBaseDocumentsOutcome ListKnowledgeBaseDocuments(const Model::ListKnowledgeBaseDocumentsRequest& request) const;
 
        template<typename ListKnowledgeBaseDocumentsRequestT = Model::ListKnowledgeBaseDocumentsRequest>
        Model::ListKnowledgeBaseDocumentsOutcomeCallable ListKnowledgeBaseDocumentsCallable(const ListKnowledgeBaseDocumentsRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ListKnowledgeBaseDocuments, request);
        }
 
        template<typename ListKnowledgeBaseDocumentsRequestT = Model::ListKnowledgeBaseDocumentsRequest>
        void ListKnowledgeBaseDocumentsAsync(const ListKnowledgeBaseDocumentsRequestT& request, const ListKnowledgeBaseDocumentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ListKnowledgeBaseDocuments, request, handler, context);
        }
 
        virtual Model::ListKnowledgeBasesOutcome ListKnowledgeBases(const Model::ListKnowledgeBasesRequest& request = {}) const;
 
        template<typename ListKnowledgeBasesRequestT = Model::ListKnowledgeBasesRequest>
        Model::ListKnowledgeBasesOutcomeCallable ListKnowledgeBasesCallable(const ListKnowledgeBasesRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockAgentClient::ListKnowledgeBases, request);
        }
 
        template<typename ListKnowledgeBasesRequestT = Model::ListKnowledgeBasesRequest>
        void ListKnowledgeBasesAsync(const ListKnowledgeBasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListKnowledgeBasesRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockAgentClient::ListKnowledgeBases, request, handler, context);
        }
 
        virtual Model::ListPromptsOutcome ListPrompts(const Model::ListPromptsRequest& request = {}) const;
 
        template<typename ListPromptsRequestT = Model::ListPromptsRequest>
        Model::ListPromptsOutcomeCallable ListPromptsCallable(const ListPromptsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockAgentClient::ListPrompts, request);
        }
 
        template<typename ListPromptsRequestT = Model::ListPromptsRequest>
        void ListPromptsAsync(const ListPromptsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPromptsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockAgentClient::ListPrompts, 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(&BedrockAgentClient::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(&BedrockAgentClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PrepareAgentOutcome PrepareAgent(const Model::PrepareAgentRequest& request) const;
 
        template<typename PrepareAgentRequestT = Model::PrepareAgentRequest>
        Model::PrepareAgentOutcomeCallable PrepareAgentCallable(const PrepareAgentRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::PrepareAgent, request);
        }
 
        template<typename PrepareAgentRequestT = Model::PrepareAgentRequest>
        void PrepareAgentAsync(const PrepareAgentRequestT& request, const PrepareAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::PrepareAgent, request, handler, context);
        }
 
        virtual Model::PrepareFlowOutcome PrepareFlow(const Model::PrepareFlowRequest& request) const;
 
        template<typename PrepareFlowRequestT = Model::PrepareFlowRequest>
        Model::PrepareFlowOutcomeCallable PrepareFlowCallable(const PrepareFlowRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::PrepareFlow, request);
        }
 
        template<typename PrepareFlowRequestT = Model::PrepareFlowRequest>
        void PrepareFlowAsync(const PrepareFlowRequestT& request, const PrepareFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::PrepareFlow, request, handler, context);
        }
 
        virtual Model::StartIngestionJobOutcome StartIngestionJob(const Model::StartIngestionJobRequest& request) const;
 
        template<typename StartIngestionJobRequestT = Model::StartIngestionJobRequest>
        Model::StartIngestionJobOutcomeCallable StartIngestionJobCallable(const StartIngestionJobRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::StartIngestionJob, request);
        }
 
        template<typename StartIngestionJobRequestT = Model::StartIngestionJobRequest>
        void StartIngestionJobAsync(const StartIngestionJobRequestT& request, const StartIngestionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::StartIngestionJob, request, handler, context);
        }
 
        virtual Model::StopIngestionJobOutcome StopIngestionJob(const Model::StopIngestionJobRequest& request) const;
 
        template<typename StopIngestionJobRequestT = Model::StopIngestionJobRequest>
        Model::StopIngestionJobOutcomeCallable StopIngestionJobCallable(const StopIngestionJobRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::StopIngestionJob, request);
        }
 
        template<typename StopIngestionJobRequestT = Model::StopIngestionJobRequest>
        void StopIngestionJobAsync(const StopIngestionJobRequestT& request, const StopIngestionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::StopIngestionJob, 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(&BedrockAgentClient::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(&BedrockAgentClient::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(&BedrockAgentClient::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(&BedrockAgentClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAgentOutcome UpdateAgent(const Model::UpdateAgentRequest& request) const;
 
        template<typename UpdateAgentRequestT = Model::UpdateAgentRequest>
        Model::UpdateAgentOutcomeCallable UpdateAgentCallable(const UpdateAgentRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdateAgent, request);
        }
 
        template<typename UpdateAgentRequestT = Model::UpdateAgentRequest>
        void UpdateAgentAsync(const UpdateAgentRequestT& request, const UpdateAgentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdateAgent, request, handler, context);
        }
 
        virtual Model::UpdateAgentActionGroupOutcome UpdateAgentActionGroup(const Model::UpdateAgentActionGroupRequest& request) const;
 
        template<typename UpdateAgentActionGroupRequestT = Model::UpdateAgentActionGroupRequest>
        Model::UpdateAgentActionGroupOutcomeCallable UpdateAgentActionGroupCallable(const UpdateAgentActionGroupRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdateAgentActionGroup, request);
        }
 
        template<typename UpdateAgentActionGroupRequestT = Model::UpdateAgentActionGroupRequest>
        void UpdateAgentActionGroupAsync(const UpdateAgentActionGroupRequestT& request, const UpdateAgentActionGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdateAgentActionGroup, request, handler, context);
        }
 
        virtual Model::UpdateAgentAliasOutcome UpdateAgentAlias(const Model::UpdateAgentAliasRequest& request) const;
 
        template<typename UpdateAgentAliasRequestT = Model::UpdateAgentAliasRequest>
        Model::UpdateAgentAliasOutcomeCallable UpdateAgentAliasCallable(const UpdateAgentAliasRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdateAgentAlias, request);
        }
 
        template<typename UpdateAgentAliasRequestT = Model::UpdateAgentAliasRequest>
        void UpdateAgentAliasAsync(const UpdateAgentAliasRequestT& request, const UpdateAgentAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdateAgentAlias, request, handler, context);
        }
 
        virtual Model::UpdateAgentCollaboratorOutcome UpdateAgentCollaborator(const Model::UpdateAgentCollaboratorRequest& request) const;
 
        template<typename UpdateAgentCollaboratorRequestT = Model::UpdateAgentCollaboratorRequest>
        Model::UpdateAgentCollaboratorOutcomeCallable UpdateAgentCollaboratorCallable(const UpdateAgentCollaboratorRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdateAgentCollaborator, request);
        }
 
        template<typename UpdateAgentCollaboratorRequestT = Model::UpdateAgentCollaboratorRequest>
        void UpdateAgentCollaboratorAsync(const UpdateAgentCollaboratorRequestT& request, const UpdateAgentCollaboratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdateAgentCollaborator, request, handler, context);
        }
 
        virtual Model::UpdateAgentKnowledgeBaseOutcome UpdateAgentKnowledgeBase(const Model::UpdateAgentKnowledgeBaseRequest& request) const;
 
        template<typename UpdateAgentKnowledgeBaseRequestT = Model::UpdateAgentKnowledgeBaseRequest>
        Model::UpdateAgentKnowledgeBaseOutcomeCallable UpdateAgentKnowledgeBaseCallable(const UpdateAgentKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdateAgentKnowledgeBase, request);
        }
 
        template<typename UpdateAgentKnowledgeBaseRequestT = Model::UpdateAgentKnowledgeBaseRequest>
        void UpdateAgentKnowledgeBaseAsync(const UpdateAgentKnowledgeBaseRequestT& request, const UpdateAgentKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdateAgentKnowledgeBase, request, handler, context);
        }
 
        virtual Model::UpdateDataSourceOutcome UpdateDataSource(const Model::UpdateDataSourceRequest& request) const;
 
        template<typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
        Model::UpdateDataSourceOutcomeCallable UpdateDataSourceCallable(const UpdateDataSourceRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdateDataSource, request);
        }
 
        template<typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
        void UpdateDataSourceAsync(const UpdateDataSourceRequestT& request, const UpdateDataSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdateDataSource, request, handler, context);
        }
 
        virtual Model::UpdateFlowOutcome UpdateFlow(const Model::UpdateFlowRequest& request) const;
 
        template<typename UpdateFlowRequestT = Model::UpdateFlowRequest>
        Model::UpdateFlowOutcomeCallable UpdateFlowCallable(const UpdateFlowRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdateFlow, request);
        }
 
        template<typename UpdateFlowRequestT = Model::UpdateFlowRequest>
        void UpdateFlowAsync(const UpdateFlowRequestT& request, const UpdateFlowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdateFlow, request, handler, context);
        }
 
        virtual Model::UpdateFlowAliasOutcome UpdateFlowAlias(const Model::UpdateFlowAliasRequest& request) const;
 
        template<typename UpdateFlowAliasRequestT = Model::UpdateFlowAliasRequest>
        Model::UpdateFlowAliasOutcomeCallable UpdateFlowAliasCallable(const UpdateFlowAliasRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdateFlowAlias, request);
        }
 
        template<typename UpdateFlowAliasRequestT = Model::UpdateFlowAliasRequest>
        void UpdateFlowAliasAsync(const UpdateFlowAliasRequestT& request, const UpdateFlowAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdateFlowAlias, request, handler, context);
        }
 
        virtual Model::UpdateKnowledgeBaseOutcome UpdateKnowledgeBase(const Model::UpdateKnowledgeBaseRequest& request) const;
 
        template<typename UpdateKnowledgeBaseRequestT = Model::UpdateKnowledgeBaseRequest>
        Model::UpdateKnowledgeBaseOutcomeCallable UpdateKnowledgeBaseCallable(const UpdateKnowledgeBaseRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdateKnowledgeBase, request);
        }
 
        template<typename UpdateKnowledgeBaseRequestT = Model::UpdateKnowledgeBaseRequest>
        void UpdateKnowledgeBaseAsync(const UpdateKnowledgeBaseRequestT& request, const UpdateKnowledgeBaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdateKnowledgeBase, request, handler, context);
        }
 
        virtual Model::UpdatePromptOutcome UpdatePrompt(const Model::UpdatePromptRequest& request) const;
 
        template<typename UpdatePromptRequestT = Model::UpdatePromptRequest>
        Model::UpdatePromptOutcomeCallable UpdatePromptCallable(const UpdatePromptRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::UpdatePrompt, request);
        }
 
        template<typename UpdatePromptRequestT = Model::UpdatePromptRequest>
        void UpdatePromptAsync(const UpdatePromptRequestT& request, const UpdatePromptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::UpdatePrompt, request, handler, context);
        }
 
        virtual Model::ValidateFlowDefinitionOutcome ValidateFlowDefinition(const Model::ValidateFlowDefinitionRequest& request) const;
 
        template<typename ValidateFlowDefinitionRequestT = Model::ValidateFlowDefinitionRequest>
        Model::ValidateFlowDefinitionOutcomeCallable ValidateFlowDefinitionCallable(const ValidateFlowDefinitionRequestT& request) const
        {
            return SubmitCallable(&BedrockAgentClient::ValidateFlowDefinition, request);
        }
 
        template<typename ValidateFlowDefinitionRequestT = Model::ValidateFlowDefinitionRequest>
        void ValidateFlowDefinitionAsync(const ValidateFlowDefinitionRequestT& request, const ValidateFlowDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockAgentClient::ValidateFlowDefinition, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BedrockAgentEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BedrockAgentClient>;
      void init(const BedrockAgentClientConfiguration& clientConfiguration);
 
      BedrockAgentClientConfiguration m_clientConfiguration;
      std::shared_ptr<BedrockAgentEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace BedrockAgent
} // namespace Aws