BedrockAgentClient.h

 
#pragma once
#include <aws/bedrock-agent/BedrockAgentErrorMarshaller.h>
#include <aws/bedrock-agent/BedrockAgentPaginationBase.h>
#include <aws/bedrock-agent/BedrockAgentServiceClientModel.h>
#include <aws/bedrock-agent/BedrockAgentWaiter.h>
#include <aws/bedrock-agent/BedrockAgent_EXPORTS.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <smithy/client/AwsSmithyClient.h>
#include <smithy/client/serializer/JsonOutcomeSerializer.h>
#include <smithy/identity/auth/built-in/GenericAuthSchemeResolver.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
 
namespace Aws {
namespace BedrockAgent {
AWS_BEDROCKAGENT_API extern const char SERVICE_NAME[];
class AWS_BEDROCKAGENT_API BedrockAgentClient
    : Aws::Client::ClientWithAsyncTemplateMethods<BedrockAgentClient>,
      public smithy::client::AwsSmithyClientT<Aws::BedrockAgent::SERVICE_NAME, Aws::BedrockAgent::BedrockAgentClientConfiguration,
                                              smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant<smithy::SigV4AuthScheme>,
                                              BedrockAgentEndpointProviderBase, smithy::client::JsonOutcomeSerializer,
                                              smithy::client::JsonOutcome, Aws::Client::BedrockAgentErrorMarshaller>,
      public BedrockAgentPaginationBase<BedrockAgentClient>,
      public BedrockAgentWaiter<BedrockAgentClient> {
 public:
  static const char* GetServiceName();
  static const char* GetAllocationTag();
  inline const char* GetServiceClientName() const override { return "Bedrock Agent"; }
 
  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::CreateVpcConfigurationOutcome CreateVpcConfiguration(const Model::CreateVpcConfigurationRequest& request) const;
 
  template <typename CreateVpcConfigurationRequestT = Model::CreateVpcConfigurationRequest>
  Model::CreateVpcConfigurationOutcomeCallable CreateVpcConfigurationCallable(const CreateVpcConfigurationRequestT& request) const {
    return SubmitCallable(&BedrockAgentClient::CreateVpcConfiguration, request);
  }
 
  template <typename CreateVpcConfigurationRequestT = Model::CreateVpcConfigurationRequest>
  void CreateVpcConfigurationAsync(const CreateVpcConfigurationRequestT& request,
                                   const CreateVpcConfigurationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentClient::CreateVpcConfiguration, 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::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const {
    return SubmitCallable(&BedrockAgentClient::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentClient::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteVpcConfigurationOutcome DeleteVpcConfiguration(const Model::DeleteVpcConfigurationRequest& request) const;
 
  template <typename DeleteVpcConfigurationRequestT = Model::DeleteVpcConfigurationRequest>
  Model::DeleteVpcConfigurationOutcomeCallable DeleteVpcConfigurationCallable(const DeleteVpcConfigurationRequestT& request) const {
    return SubmitCallable(&BedrockAgentClient::DeleteVpcConfiguration, request);
  }
 
  template <typename DeleteVpcConfigurationRequestT = Model::DeleteVpcConfigurationRequest>
  void DeleteVpcConfigurationAsync(const DeleteVpcConfigurationRequestT& request,
                                   const DeleteVpcConfigurationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentClient::DeleteVpcConfiguration, 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::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&BedrockAgentClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::GetVpcConfigurationOutcome GetVpcConfiguration(const Model::GetVpcConfigurationRequest& request) const;
 
  template <typename GetVpcConfigurationRequestT = Model::GetVpcConfigurationRequest>
  Model::GetVpcConfigurationOutcomeCallable GetVpcConfigurationCallable(const GetVpcConfigurationRequestT& request) const {
    return SubmitCallable(&BedrockAgentClient::GetVpcConfiguration, request);
  }
 
  template <typename GetVpcConfigurationRequestT = Model::GetVpcConfigurationRequest>
  void GetVpcConfigurationAsync(const GetVpcConfigurationRequestT& request, const GetVpcConfigurationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentClient::GetVpcConfiguration, 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::ListVpcConfigurationsOutcome ListVpcConfigurations(const Model::ListVpcConfigurationsRequest& request) const;
 
  template <typename ListVpcConfigurationsRequestT = Model::ListVpcConfigurationsRequest>
  Model::ListVpcConfigurationsOutcomeCallable ListVpcConfigurationsCallable(const ListVpcConfigurationsRequestT& request) const {
    return SubmitCallable(&BedrockAgentClient::ListVpcConfigurations, request);
  }
 
  template <typename ListVpcConfigurationsRequestT = Model::ListVpcConfigurationsRequest>
  void ListVpcConfigurationsAsync(const ListVpcConfigurationsRequestT& request, const ListVpcConfigurationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentClient::ListVpcConfigurations, 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::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&BedrockAgentClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockAgentClient::PutResourcePolicy, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<BedrockAgentEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BedrockAgentClient>;
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>, BedrockAgentError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::AWSEndpoint&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
};
 
}  // namespace BedrockAgent
}  // namespace Aws