BedrockClient.h

 
#pragma once
#include <aws/bedrock/Bedrock_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/BedrockServiceClientModel.h>
 
namespace Aws
{
namespace Bedrock
{
  class AWS_BEDROCK_API BedrockClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<BedrockClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef BedrockClientConfiguration ClientConfigurationType;
      typedef BedrockEndpointProvider EndpointProviderType;
 
        BedrockClient(const Aws::Bedrock::BedrockClientConfiguration& clientConfiguration = Aws::Bedrock::BedrockClientConfiguration(),
                      std::shared_ptr<BedrockEndpointProviderBase> endpointProvider = nullptr);
 
        BedrockClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<BedrockEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Bedrock::BedrockClientConfiguration& clientConfiguration = Aws::Bedrock::BedrockClientConfiguration());
 
        BedrockClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<BedrockEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Bedrock::BedrockClientConfiguration& clientConfiguration = Aws::Bedrock::BedrockClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        BedrockClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BedrockClient(const Aws::Auth::AWSCredentials& credentials,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BedrockClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~BedrockClient();
 
        virtual Model::BatchDeleteEvaluationJobOutcome BatchDeleteEvaluationJob(const Model::BatchDeleteEvaluationJobRequest& request) const;
 
        template<typename BatchDeleteEvaluationJobRequestT = Model::BatchDeleteEvaluationJobRequest>
        Model::BatchDeleteEvaluationJobOutcomeCallable BatchDeleteEvaluationJobCallable(const BatchDeleteEvaluationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::BatchDeleteEvaluationJob, request);
        }
 
        template<typename BatchDeleteEvaluationJobRequestT = Model::BatchDeleteEvaluationJobRequest>
        void BatchDeleteEvaluationJobAsync(const BatchDeleteEvaluationJobRequestT& request, const BatchDeleteEvaluationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::BatchDeleteEvaluationJob, request, handler, context);
        }
 
        virtual Model::CreateCustomModelOutcome CreateCustomModel(const Model::CreateCustomModelRequest& request) const;
 
        template<typename CreateCustomModelRequestT = Model::CreateCustomModelRequest>
        Model::CreateCustomModelOutcomeCallable CreateCustomModelCallable(const CreateCustomModelRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateCustomModel, request);
        }
 
        template<typename CreateCustomModelRequestT = Model::CreateCustomModelRequest>
        void CreateCustomModelAsync(const CreateCustomModelRequestT& request, const CreateCustomModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateCustomModel, request, handler, context);
        }
 
        virtual Model::CreateCustomModelDeploymentOutcome CreateCustomModelDeployment(const Model::CreateCustomModelDeploymentRequest& request) const;
 
        template<typename CreateCustomModelDeploymentRequestT = Model::CreateCustomModelDeploymentRequest>
        Model::CreateCustomModelDeploymentOutcomeCallable CreateCustomModelDeploymentCallable(const CreateCustomModelDeploymentRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateCustomModelDeployment, request);
        }
 
        template<typename CreateCustomModelDeploymentRequestT = Model::CreateCustomModelDeploymentRequest>
        void CreateCustomModelDeploymentAsync(const CreateCustomModelDeploymentRequestT& request, const CreateCustomModelDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateCustomModelDeployment, request, handler, context);
        }
 
        virtual Model::CreateEvaluationJobOutcome CreateEvaluationJob(const Model::CreateEvaluationJobRequest& request) const;
 
        template<typename CreateEvaluationJobRequestT = Model::CreateEvaluationJobRequest>
        Model::CreateEvaluationJobOutcomeCallable CreateEvaluationJobCallable(const CreateEvaluationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateEvaluationJob, request);
        }
 
        template<typename CreateEvaluationJobRequestT = Model::CreateEvaluationJobRequest>
        void CreateEvaluationJobAsync(const CreateEvaluationJobRequestT& request, const CreateEvaluationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateEvaluationJob, request, handler, context);
        }
 
        virtual Model::CreateFoundationModelAgreementOutcome CreateFoundationModelAgreement(const Model::CreateFoundationModelAgreementRequest& request) const;
 
        template<typename CreateFoundationModelAgreementRequestT = Model::CreateFoundationModelAgreementRequest>
        Model::CreateFoundationModelAgreementOutcomeCallable CreateFoundationModelAgreementCallable(const CreateFoundationModelAgreementRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateFoundationModelAgreement, request);
        }
 
        template<typename CreateFoundationModelAgreementRequestT = Model::CreateFoundationModelAgreementRequest>
        void CreateFoundationModelAgreementAsync(const CreateFoundationModelAgreementRequestT& request, const CreateFoundationModelAgreementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateFoundationModelAgreement, request, handler, context);
        }
 
        virtual Model::CreateGuardrailOutcome CreateGuardrail(const Model::CreateGuardrailRequest& request) const;
 
        template<typename CreateGuardrailRequestT = Model::CreateGuardrailRequest>
        Model::CreateGuardrailOutcomeCallable CreateGuardrailCallable(const CreateGuardrailRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateGuardrail, request);
        }
 
        template<typename CreateGuardrailRequestT = Model::CreateGuardrailRequest>
        void CreateGuardrailAsync(const CreateGuardrailRequestT& request, const CreateGuardrailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateGuardrail, request, handler, context);
        }
 
        virtual Model::CreateGuardrailVersionOutcome CreateGuardrailVersion(const Model::CreateGuardrailVersionRequest& request) const;
 
        template<typename CreateGuardrailVersionRequestT = Model::CreateGuardrailVersionRequest>
        Model::CreateGuardrailVersionOutcomeCallable CreateGuardrailVersionCallable(const CreateGuardrailVersionRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateGuardrailVersion, request);
        }
 
        template<typename CreateGuardrailVersionRequestT = Model::CreateGuardrailVersionRequest>
        void CreateGuardrailVersionAsync(const CreateGuardrailVersionRequestT& request, const CreateGuardrailVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateGuardrailVersion, request, handler, context);
        }
 
        virtual Model::CreateInferenceProfileOutcome CreateInferenceProfile(const Model::CreateInferenceProfileRequest& request) const;
 
        template<typename CreateInferenceProfileRequestT = Model::CreateInferenceProfileRequest>
        Model::CreateInferenceProfileOutcomeCallable CreateInferenceProfileCallable(const CreateInferenceProfileRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateInferenceProfile, request);
        }
 
        template<typename CreateInferenceProfileRequestT = Model::CreateInferenceProfileRequest>
        void CreateInferenceProfileAsync(const CreateInferenceProfileRequestT& request, const CreateInferenceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateInferenceProfile, request, handler, context);
        }
 
        virtual Model::CreateMarketplaceModelEndpointOutcome CreateMarketplaceModelEndpoint(const Model::CreateMarketplaceModelEndpointRequest& request) const;
 
        template<typename CreateMarketplaceModelEndpointRequestT = Model::CreateMarketplaceModelEndpointRequest>
        Model::CreateMarketplaceModelEndpointOutcomeCallable CreateMarketplaceModelEndpointCallable(const CreateMarketplaceModelEndpointRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateMarketplaceModelEndpoint, request);
        }
 
        template<typename CreateMarketplaceModelEndpointRequestT = Model::CreateMarketplaceModelEndpointRequest>
        void CreateMarketplaceModelEndpointAsync(const CreateMarketplaceModelEndpointRequestT& request, const CreateMarketplaceModelEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateMarketplaceModelEndpoint, request, handler, context);
        }
 
        virtual Model::CreateModelCopyJobOutcome CreateModelCopyJob(const Model::CreateModelCopyJobRequest& request) const;
 
        template<typename CreateModelCopyJobRequestT = Model::CreateModelCopyJobRequest>
        Model::CreateModelCopyJobOutcomeCallable CreateModelCopyJobCallable(const CreateModelCopyJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateModelCopyJob, request);
        }
 
        template<typename CreateModelCopyJobRequestT = Model::CreateModelCopyJobRequest>
        void CreateModelCopyJobAsync(const CreateModelCopyJobRequestT& request, const CreateModelCopyJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateModelCopyJob, request, handler, context);
        }
 
        virtual Model::CreateModelCustomizationJobOutcome CreateModelCustomizationJob(const Model::CreateModelCustomizationJobRequest& request) const;
 
        template<typename CreateModelCustomizationJobRequestT = Model::CreateModelCustomizationJobRequest>
        Model::CreateModelCustomizationJobOutcomeCallable CreateModelCustomizationJobCallable(const CreateModelCustomizationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateModelCustomizationJob, request);
        }
 
        template<typename CreateModelCustomizationJobRequestT = Model::CreateModelCustomizationJobRequest>
        void CreateModelCustomizationJobAsync(const CreateModelCustomizationJobRequestT& request, const CreateModelCustomizationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateModelCustomizationJob, request, handler, context);
        }
 
        virtual Model::CreateModelImportJobOutcome CreateModelImportJob(const Model::CreateModelImportJobRequest& request) const;
 
        template<typename CreateModelImportJobRequestT = Model::CreateModelImportJobRequest>
        Model::CreateModelImportJobOutcomeCallable CreateModelImportJobCallable(const CreateModelImportJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateModelImportJob, request);
        }
 
        template<typename CreateModelImportJobRequestT = Model::CreateModelImportJobRequest>
        void CreateModelImportJobAsync(const CreateModelImportJobRequestT& request, const CreateModelImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateModelImportJob, request, handler, context);
        }
 
        virtual Model::CreateModelInvocationJobOutcome CreateModelInvocationJob(const Model::CreateModelInvocationJobRequest& request) const;
 
        template<typename CreateModelInvocationJobRequestT = Model::CreateModelInvocationJobRequest>
        Model::CreateModelInvocationJobOutcomeCallable CreateModelInvocationJobCallable(const CreateModelInvocationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateModelInvocationJob, request);
        }
 
        template<typename CreateModelInvocationJobRequestT = Model::CreateModelInvocationJobRequest>
        void CreateModelInvocationJobAsync(const CreateModelInvocationJobRequestT& request, const CreateModelInvocationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateModelInvocationJob, request, handler, context);
        }
 
        virtual Model::CreatePromptRouterOutcome CreatePromptRouter(const Model::CreatePromptRouterRequest& request) const;
 
        template<typename CreatePromptRouterRequestT = Model::CreatePromptRouterRequest>
        Model::CreatePromptRouterOutcomeCallable CreatePromptRouterCallable(const CreatePromptRouterRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreatePromptRouter, request);
        }
 
        template<typename CreatePromptRouterRequestT = Model::CreatePromptRouterRequest>
        void CreatePromptRouterAsync(const CreatePromptRouterRequestT& request, const CreatePromptRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreatePromptRouter, request, handler, context);
        }
 
        virtual Model::CreateProvisionedModelThroughputOutcome CreateProvisionedModelThroughput(const Model::CreateProvisionedModelThroughputRequest& request) const;
 
        template<typename CreateProvisionedModelThroughputRequestT = Model::CreateProvisionedModelThroughputRequest>
        Model::CreateProvisionedModelThroughputOutcomeCallable CreateProvisionedModelThroughputCallable(const CreateProvisionedModelThroughputRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateProvisionedModelThroughput, request);
        }
 
        template<typename CreateProvisionedModelThroughputRequestT = Model::CreateProvisionedModelThroughputRequest>
        void CreateProvisionedModelThroughputAsync(const CreateProvisionedModelThroughputRequestT& request, const CreateProvisionedModelThroughputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateProvisionedModelThroughput, request, handler, context);
        }
 
        virtual Model::DeleteCustomModelOutcome DeleteCustomModel(const Model::DeleteCustomModelRequest& request) const;
 
        template<typename DeleteCustomModelRequestT = Model::DeleteCustomModelRequest>
        Model::DeleteCustomModelOutcomeCallable DeleteCustomModelCallable(const DeleteCustomModelRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteCustomModel, request);
        }
 
        template<typename DeleteCustomModelRequestT = Model::DeleteCustomModelRequest>
        void DeleteCustomModelAsync(const DeleteCustomModelRequestT& request, const DeleteCustomModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteCustomModel, request, handler, context);
        }
 
        virtual Model::DeleteCustomModelDeploymentOutcome DeleteCustomModelDeployment(const Model::DeleteCustomModelDeploymentRequest& request) const;
 
        template<typename DeleteCustomModelDeploymentRequestT = Model::DeleteCustomModelDeploymentRequest>
        Model::DeleteCustomModelDeploymentOutcomeCallable DeleteCustomModelDeploymentCallable(const DeleteCustomModelDeploymentRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteCustomModelDeployment, request);
        }
 
        template<typename DeleteCustomModelDeploymentRequestT = Model::DeleteCustomModelDeploymentRequest>
        void DeleteCustomModelDeploymentAsync(const DeleteCustomModelDeploymentRequestT& request, const DeleteCustomModelDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteCustomModelDeployment, request, handler, context);
        }
 
        virtual Model::DeleteFoundationModelAgreementOutcome DeleteFoundationModelAgreement(const Model::DeleteFoundationModelAgreementRequest& request) const;
 
        template<typename DeleteFoundationModelAgreementRequestT = Model::DeleteFoundationModelAgreementRequest>
        Model::DeleteFoundationModelAgreementOutcomeCallable DeleteFoundationModelAgreementCallable(const DeleteFoundationModelAgreementRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteFoundationModelAgreement, request);
        }
 
        template<typename DeleteFoundationModelAgreementRequestT = Model::DeleteFoundationModelAgreementRequest>
        void DeleteFoundationModelAgreementAsync(const DeleteFoundationModelAgreementRequestT& request, const DeleteFoundationModelAgreementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteFoundationModelAgreement, request, handler, context);
        }
 
        virtual Model::DeleteGuardrailOutcome DeleteGuardrail(const Model::DeleteGuardrailRequest& request) const;
 
        template<typename DeleteGuardrailRequestT = Model::DeleteGuardrailRequest>
        Model::DeleteGuardrailOutcomeCallable DeleteGuardrailCallable(const DeleteGuardrailRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteGuardrail, request);
        }
 
        template<typename DeleteGuardrailRequestT = Model::DeleteGuardrailRequest>
        void DeleteGuardrailAsync(const DeleteGuardrailRequestT& request, const DeleteGuardrailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteGuardrail, request, handler, context);
        }
 
        virtual Model::DeleteImportedModelOutcome DeleteImportedModel(const Model::DeleteImportedModelRequest& request) const;
 
        template<typename DeleteImportedModelRequestT = Model::DeleteImportedModelRequest>
        Model::DeleteImportedModelOutcomeCallable DeleteImportedModelCallable(const DeleteImportedModelRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteImportedModel, request);
        }
 
        template<typename DeleteImportedModelRequestT = Model::DeleteImportedModelRequest>
        void DeleteImportedModelAsync(const DeleteImportedModelRequestT& request, const DeleteImportedModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteImportedModel, request, handler, context);
        }
 
        virtual Model::DeleteInferenceProfileOutcome DeleteInferenceProfile(const Model::DeleteInferenceProfileRequest& request) const;
 
        template<typename DeleteInferenceProfileRequestT = Model::DeleteInferenceProfileRequest>
        Model::DeleteInferenceProfileOutcomeCallable DeleteInferenceProfileCallable(const DeleteInferenceProfileRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteInferenceProfile, request);
        }
 
        template<typename DeleteInferenceProfileRequestT = Model::DeleteInferenceProfileRequest>
        void DeleteInferenceProfileAsync(const DeleteInferenceProfileRequestT& request, const DeleteInferenceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteInferenceProfile, request, handler, context);
        }
 
        virtual Model::DeleteMarketplaceModelEndpointOutcome DeleteMarketplaceModelEndpoint(const Model::DeleteMarketplaceModelEndpointRequest& request) const;
 
        template<typename DeleteMarketplaceModelEndpointRequestT = Model::DeleteMarketplaceModelEndpointRequest>
        Model::DeleteMarketplaceModelEndpointOutcomeCallable DeleteMarketplaceModelEndpointCallable(const DeleteMarketplaceModelEndpointRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteMarketplaceModelEndpoint, request);
        }
 
        template<typename DeleteMarketplaceModelEndpointRequestT = Model::DeleteMarketplaceModelEndpointRequest>
        void DeleteMarketplaceModelEndpointAsync(const DeleteMarketplaceModelEndpointRequestT& request, const DeleteMarketplaceModelEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteMarketplaceModelEndpoint, request, handler, context);
        }
 
        virtual Model::DeleteModelInvocationLoggingConfigurationOutcome DeleteModelInvocationLoggingConfiguration(const Model::DeleteModelInvocationLoggingConfigurationRequest& request = {}) const;
 
        template<typename DeleteModelInvocationLoggingConfigurationRequestT = Model::DeleteModelInvocationLoggingConfigurationRequest>
        Model::DeleteModelInvocationLoggingConfigurationOutcomeCallable DeleteModelInvocationLoggingConfigurationCallable(const DeleteModelInvocationLoggingConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::DeleteModelInvocationLoggingConfiguration, request);
        }
 
        template<typename DeleteModelInvocationLoggingConfigurationRequestT = Model::DeleteModelInvocationLoggingConfigurationRequest>
        void DeleteModelInvocationLoggingConfigurationAsync(const DeleteModelInvocationLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteModelInvocationLoggingConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::DeleteModelInvocationLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::DeletePromptRouterOutcome DeletePromptRouter(const Model::DeletePromptRouterRequest& request) const;
 
        template<typename DeletePromptRouterRequestT = Model::DeletePromptRouterRequest>
        Model::DeletePromptRouterOutcomeCallable DeletePromptRouterCallable(const DeletePromptRouterRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeletePromptRouter, request);
        }
 
        template<typename DeletePromptRouterRequestT = Model::DeletePromptRouterRequest>
        void DeletePromptRouterAsync(const DeletePromptRouterRequestT& request, const DeletePromptRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeletePromptRouter, request, handler, context);
        }
 
        virtual Model::DeleteProvisionedModelThroughputOutcome DeleteProvisionedModelThroughput(const Model::DeleteProvisionedModelThroughputRequest& request) const;
 
        template<typename DeleteProvisionedModelThroughputRequestT = Model::DeleteProvisionedModelThroughputRequest>
        Model::DeleteProvisionedModelThroughputOutcomeCallable DeleteProvisionedModelThroughputCallable(const DeleteProvisionedModelThroughputRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteProvisionedModelThroughput, request);
        }
 
        template<typename DeleteProvisionedModelThroughputRequestT = Model::DeleteProvisionedModelThroughputRequest>
        void DeleteProvisionedModelThroughputAsync(const DeleteProvisionedModelThroughputRequestT& request, const DeleteProvisionedModelThroughputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteProvisionedModelThroughput, request, handler, context);
        }
 
        virtual Model::DeregisterMarketplaceModelEndpointOutcome DeregisterMarketplaceModelEndpoint(const Model::DeregisterMarketplaceModelEndpointRequest& request) const;
 
        template<typename DeregisterMarketplaceModelEndpointRequestT = Model::DeregisterMarketplaceModelEndpointRequest>
        Model::DeregisterMarketplaceModelEndpointOutcomeCallable DeregisterMarketplaceModelEndpointCallable(const DeregisterMarketplaceModelEndpointRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeregisterMarketplaceModelEndpoint, request);
        }
 
        template<typename DeregisterMarketplaceModelEndpointRequestT = Model::DeregisterMarketplaceModelEndpointRequest>
        void DeregisterMarketplaceModelEndpointAsync(const DeregisterMarketplaceModelEndpointRequestT& request, const DeregisterMarketplaceModelEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeregisterMarketplaceModelEndpoint, request, handler, context);
        }
 
        virtual Model::GetCustomModelOutcome GetCustomModel(const Model::GetCustomModelRequest& request) const;
 
        template<typename GetCustomModelRequestT = Model::GetCustomModelRequest>
        Model::GetCustomModelOutcomeCallable GetCustomModelCallable(const GetCustomModelRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetCustomModel, request);
        }
 
        template<typename GetCustomModelRequestT = Model::GetCustomModelRequest>
        void GetCustomModelAsync(const GetCustomModelRequestT& request, const GetCustomModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetCustomModel, request, handler, context);
        }
 
        virtual Model::GetCustomModelDeploymentOutcome GetCustomModelDeployment(const Model::GetCustomModelDeploymentRequest& request) const;
 
        template<typename GetCustomModelDeploymentRequestT = Model::GetCustomModelDeploymentRequest>
        Model::GetCustomModelDeploymentOutcomeCallable GetCustomModelDeploymentCallable(const GetCustomModelDeploymentRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetCustomModelDeployment, request);
        }
 
        template<typename GetCustomModelDeploymentRequestT = Model::GetCustomModelDeploymentRequest>
        void GetCustomModelDeploymentAsync(const GetCustomModelDeploymentRequestT& request, const GetCustomModelDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetCustomModelDeployment, request, handler, context);
        }
 
        virtual Model::GetEvaluationJobOutcome GetEvaluationJob(const Model::GetEvaluationJobRequest& request) const;
 
        template<typename GetEvaluationJobRequestT = Model::GetEvaluationJobRequest>
        Model::GetEvaluationJobOutcomeCallable GetEvaluationJobCallable(const GetEvaluationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetEvaluationJob, request);
        }
 
        template<typename GetEvaluationJobRequestT = Model::GetEvaluationJobRequest>
        void GetEvaluationJobAsync(const GetEvaluationJobRequestT& request, const GetEvaluationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetEvaluationJob, request, handler, context);
        }
 
        virtual Model::GetFoundationModelOutcome GetFoundationModel(const Model::GetFoundationModelRequest& request) const;
 
        template<typename GetFoundationModelRequestT = Model::GetFoundationModelRequest>
        Model::GetFoundationModelOutcomeCallable GetFoundationModelCallable(const GetFoundationModelRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetFoundationModel, request);
        }
 
        template<typename GetFoundationModelRequestT = Model::GetFoundationModelRequest>
        void GetFoundationModelAsync(const GetFoundationModelRequestT& request, const GetFoundationModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetFoundationModel, request, handler, context);
        }
 
        virtual Model::GetFoundationModelAvailabilityOutcome GetFoundationModelAvailability(const Model::GetFoundationModelAvailabilityRequest& request) const;
 
        template<typename GetFoundationModelAvailabilityRequestT = Model::GetFoundationModelAvailabilityRequest>
        Model::GetFoundationModelAvailabilityOutcomeCallable GetFoundationModelAvailabilityCallable(const GetFoundationModelAvailabilityRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetFoundationModelAvailability, request);
        }
 
        template<typename GetFoundationModelAvailabilityRequestT = Model::GetFoundationModelAvailabilityRequest>
        void GetFoundationModelAvailabilityAsync(const GetFoundationModelAvailabilityRequestT& request, const GetFoundationModelAvailabilityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetFoundationModelAvailability, request, handler, context);
        }
 
        virtual Model::GetGuardrailOutcome GetGuardrail(const Model::GetGuardrailRequest& request) const;
 
        template<typename GetGuardrailRequestT = Model::GetGuardrailRequest>
        Model::GetGuardrailOutcomeCallable GetGuardrailCallable(const GetGuardrailRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetGuardrail, request);
        }
 
        template<typename GetGuardrailRequestT = Model::GetGuardrailRequest>
        void GetGuardrailAsync(const GetGuardrailRequestT& request, const GetGuardrailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetGuardrail, request, handler, context);
        }
 
        virtual Model::GetImportedModelOutcome GetImportedModel(const Model::GetImportedModelRequest& request) const;
 
        template<typename GetImportedModelRequestT = Model::GetImportedModelRequest>
        Model::GetImportedModelOutcomeCallable GetImportedModelCallable(const GetImportedModelRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetImportedModel, request);
        }
 
        template<typename GetImportedModelRequestT = Model::GetImportedModelRequest>
        void GetImportedModelAsync(const GetImportedModelRequestT& request, const GetImportedModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetImportedModel, request, handler, context);
        }
 
        virtual Model::GetInferenceProfileOutcome GetInferenceProfile(const Model::GetInferenceProfileRequest& request) const;
 
        template<typename GetInferenceProfileRequestT = Model::GetInferenceProfileRequest>
        Model::GetInferenceProfileOutcomeCallable GetInferenceProfileCallable(const GetInferenceProfileRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetInferenceProfile, request);
        }
 
        template<typename GetInferenceProfileRequestT = Model::GetInferenceProfileRequest>
        void GetInferenceProfileAsync(const GetInferenceProfileRequestT& request, const GetInferenceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetInferenceProfile, request, handler, context);
        }
 
        virtual Model::GetMarketplaceModelEndpointOutcome GetMarketplaceModelEndpoint(const Model::GetMarketplaceModelEndpointRequest& request) const;
 
        template<typename GetMarketplaceModelEndpointRequestT = Model::GetMarketplaceModelEndpointRequest>
        Model::GetMarketplaceModelEndpointOutcomeCallable GetMarketplaceModelEndpointCallable(const GetMarketplaceModelEndpointRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetMarketplaceModelEndpoint, request);
        }
 
        template<typename GetMarketplaceModelEndpointRequestT = Model::GetMarketplaceModelEndpointRequest>
        void GetMarketplaceModelEndpointAsync(const GetMarketplaceModelEndpointRequestT& request, const GetMarketplaceModelEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetMarketplaceModelEndpoint, request, handler, context);
        }
 
        virtual Model::GetModelCopyJobOutcome GetModelCopyJob(const Model::GetModelCopyJobRequest& request) const;
 
        template<typename GetModelCopyJobRequestT = Model::GetModelCopyJobRequest>
        Model::GetModelCopyJobOutcomeCallable GetModelCopyJobCallable(const GetModelCopyJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetModelCopyJob, request);
        }
 
        template<typename GetModelCopyJobRequestT = Model::GetModelCopyJobRequest>
        void GetModelCopyJobAsync(const GetModelCopyJobRequestT& request, const GetModelCopyJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetModelCopyJob, request, handler, context);
        }
 
        virtual Model::GetModelCustomizationJobOutcome GetModelCustomizationJob(const Model::GetModelCustomizationJobRequest& request) const;
 
        template<typename GetModelCustomizationJobRequestT = Model::GetModelCustomizationJobRequest>
        Model::GetModelCustomizationJobOutcomeCallable GetModelCustomizationJobCallable(const GetModelCustomizationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetModelCustomizationJob, request);
        }
 
        template<typename GetModelCustomizationJobRequestT = Model::GetModelCustomizationJobRequest>
        void GetModelCustomizationJobAsync(const GetModelCustomizationJobRequestT& request, const GetModelCustomizationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetModelCustomizationJob, request, handler, context);
        }
 
        virtual Model::GetModelImportJobOutcome GetModelImportJob(const Model::GetModelImportJobRequest& request) const;
 
        template<typename GetModelImportJobRequestT = Model::GetModelImportJobRequest>
        Model::GetModelImportJobOutcomeCallable GetModelImportJobCallable(const GetModelImportJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetModelImportJob, request);
        }
 
        template<typename GetModelImportJobRequestT = Model::GetModelImportJobRequest>
        void GetModelImportJobAsync(const GetModelImportJobRequestT& request, const GetModelImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetModelImportJob, request, handler, context);
        }
 
        virtual Model::GetModelInvocationJobOutcome GetModelInvocationJob(const Model::GetModelInvocationJobRequest& request) const;
 
        template<typename GetModelInvocationJobRequestT = Model::GetModelInvocationJobRequest>
        Model::GetModelInvocationJobOutcomeCallable GetModelInvocationJobCallable(const GetModelInvocationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetModelInvocationJob, request);
        }
 
        template<typename GetModelInvocationJobRequestT = Model::GetModelInvocationJobRequest>
        void GetModelInvocationJobAsync(const GetModelInvocationJobRequestT& request, const GetModelInvocationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetModelInvocationJob, request, handler, context);
        }
 
        virtual Model::GetModelInvocationLoggingConfigurationOutcome GetModelInvocationLoggingConfiguration(const Model::GetModelInvocationLoggingConfigurationRequest& request = {}) const;
 
        template<typename GetModelInvocationLoggingConfigurationRequestT = Model::GetModelInvocationLoggingConfigurationRequest>
        Model::GetModelInvocationLoggingConfigurationOutcomeCallable GetModelInvocationLoggingConfigurationCallable(const GetModelInvocationLoggingConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::GetModelInvocationLoggingConfiguration, request);
        }
 
        template<typename GetModelInvocationLoggingConfigurationRequestT = Model::GetModelInvocationLoggingConfigurationRequest>
        void GetModelInvocationLoggingConfigurationAsync(const GetModelInvocationLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetModelInvocationLoggingConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::GetModelInvocationLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::GetPromptRouterOutcome GetPromptRouter(const Model::GetPromptRouterRequest& request) const;
 
        template<typename GetPromptRouterRequestT = Model::GetPromptRouterRequest>
        Model::GetPromptRouterOutcomeCallable GetPromptRouterCallable(const GetPromptRouterRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetPromptRouter, request);
        }
 
        template<typename GetPromptRouterRequestT = Model::GetPromptRouterRequest>
        void GetPromptRouterAsync(const GetPromptRouterRequestT& request, const GetPromptRouterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetPromptRouter, request, handler, context);
        }
 
        virtual Model::GetProvisionedModelThroughputOutcome GetProvisionedModelThroughput(const Model::GetProvisionedModelThroughputRequest& request) const;
 
        template<typename GetProvisionedModelThroughputRequestT = Model::GetProvisionedModelThroughputRequest>
        Model::GetProvisionedModelThroughputOutcomeCallable GetProvisionedModelThroughputCallable(const GetProvisionedModelThroughputRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetProvisionedModelThroughput, request);
        }
 
        template<typename GetProvisionedModelThroughputRequestT = Model::GetProvisionedModelThroughputRequest>
        void GetProvisionedModelThroughputAsync(const GetProvisionedModelThroughputRequestT& request, const GetProvisionedModelThroughputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetProvisionedModelThroughput, request, handler, context);
        }
 
        virtual Model::GetUseCaseForModelAccessOutcome GetUseCaseForModelAccess(const Model::GetUseCaseForModelAccessRequest& request = {}) const;
 
        template<typename GetUseCaseForModelAccessRequestT = Model::GetUseCaseForModelAccessRequest>
        Model::GetUseCaseForModelAccessOutcomeCallable GetUseCaseForModelAccessCallable(const GetUseCaseForModelAccessRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::GetUseCaseForModelAccess, request);
        }
 
        template<typename GetUseCaseForModelAccessRequestT = Model::GetUseCaseForModelAccessRequest>
        void GetUseCaseForModelAccessAsync(const GetUseCaseForModelAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetUseCaseForModelAccessRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::GetUseCaseForModelAccess, request, handler, context);
        }
 
        virtual Model::ListCustomModelDeploymentsOutcome ListCustomModelDeployments(const Model::ListCustomModelDeploymentsRequest& request = {}) const;
 
        template<typename ListCustomModelDeploymentsRequestT = Model::ListCustomModelDeploymentsRequest>
        Model::ListCustomModelDeploymentsOutcomeCallable ListCustomModelDeploymentsCallable(const ListCustomModelDeploymentsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListCustomModelDeployments, request);
        }
 
        template<typename ListCustomModelDeploymentsRequestT = Model::ListCustomModelDeploymentsRequest>
        void ListCustomModelDeploymentsAsync(const ListCustomModelDeploymentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCustomModelDeploymentsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListCustomModelDeployments, request, handler, context);
        }
 
        virtual Model::ListCustomModelsOutcome ListCustomModels(const Model::ListCustomModelsRequest& request = {}) const;
 
        template<typename ListCustomModelsRequestT = Model::ListCustomModelsRequest>
        Model::ListCustomModelsOutcomeCallable ListCustomModelsCallable(const ListCustomModelsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListCustomModels, request);
        }
 
        template<typename ListCustomModelsRequestT = Model::ListCustomModelsRequest>
        void ListCustomModelsAsync(const ListCustomModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCustomModelsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListCustomModels, request, handler, context);
        }
 
        virtual Model::ListEvaluationJobsOutcome ListEvaluationJobs(const Model::ListEvaluationJobsRequest& request = {}) const;
 
        template<typename ListEvaluationJobsRequestT = Model::ListEvaluationJobsRequest>
        Model::ListEvaluationJobsOutcomeCallable ListEvaluationJobsCallable(const ListEvaluationJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListEvaluationJobs, request);
        }
 
        template<typename ListEvaluationJobsRequestT = Model::ListEvaluationJobsRequest>
        void ListEvaluationJobsAsync(const ListEvaluationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEvaluationJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListEvaluationJobs, request, handler, context);
        }
 
        virtual Model::ListFoundationModelAgreementOffersOutcome ListFoundationModelAgreementOffers(const Model::ListFoundationModelAgreementOffersRequest& request) const;
 
        template<typename ListFoundationModelAgreementOffersRequestT = Model::ListFoundationModelAgreementOffersRequest>
        Model::ListFoundationModelAgreementOffersOutcomeCallable ListFoundationModelAgreementOffersCallable(const ListFoundationModelAgreementOffersRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::ListFoundationModelAgreementOffers, request);
        }
 
        template<typename ListFoundationModelAgreementOffersRequestT = Model::ListFoundationModelAgreementOffersRequest>
        void ListFoundationModelAgreementOffersAsync(const ListFoundationModelAgreementOffersRequestT& request, const ListFoundationModelAgreementOffersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::ListFoundationModelAgreementOffers, request, handler, context);
        }
 
        virtual Model::ListFoundationModelsOutcome ListFoundationModels(const Model::ListFoundationModelsRequest& request = {}) const;
 
        template<typename ListFoundationModelsRequestT = Model::ListFoundationModelsRequest>
        Model::ListFoundationModelsOutcomeCallable ListFoundationModelsCallable(const ListFoundationModelsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListFoundationModels, request);
        }
 
        template<typename ListFoundationModelsRequestT = Model::ListFoundationModelsRequest>
        void ListFoundationModelsAsync(const ListFoundationModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFoundationModelsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListFoundationModels, request, handler, context);
        }
 
        virtual Model::ListGuardrailsOutcome ListGuardrails(const Model::ListGuardrailsRequest& request = {}) const;
 
        template<typename ListGuardrailsRequestT = Model::ListGuardrailsRequest>
        Model::ListGuardrailsOutcomeCallable ListGuardrailsCallable(const ListGuardrailsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListGuardrails, request);
        }
 
        template<typename ListGuardrailsRequestT = Model::ListGuardrailsRequest>
        void ListGuardrailsAsync(const ListGuardrailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGuardrailsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListGuardrails, request, handler, context);
        }
 
        virtual Model::ListImportedModelsOutcome ListImportedModels(const Model::ListImportedModelsRequest& request = {}) const;
 
        template<typename ListImportedModelsRequestT = Model::ListImportedModelsRequest>
        Model::ListImportedModelsOutcomeCallable ListImportedModelsCallable(const ListImportedModelsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListImportedModels, request);
        }
 
        template<typename ListImportedModelsRequestT = Model::ListImportedModelsRequest>
        void ListImportedModelsAsync(const ListImportedModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListImportedModelsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListImportedModels, request, handler, context);
        }
 
        virtual Model::ListInferenceProfilesOutcome ListInferenceProfiles(const Model::ListInferenceProfilesRequest& request = {}) const;
 
        template<typename ListInferenceProfilesRequestT = Model::ListInferenceProfilesRequest>
        Model::ListInferenceProfilesOutcomeCallable ListInferenceProfilesCallable(const ListInferenceProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListInferenceProfiles, request);
        }
 
        template<typename ListInferenceProfilesRequestT = Model::ListInferenceProfilesRequest>
        void ListInferenceProfilesAsync(const ListInferenceProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInferenceProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListInferenceProfiles, request, handler, context);
        }
 
        virtual Model::ListMarketplaceModelEndpointsOutcome ListMarketplaceModelEndpoints(const Model::ListMarketplaceModelEndpointsRequest& request = {}) const;
 
        template<typename ListMarketplaceModelEndpointsRequestT = Model::ListMarketplaceModelEndpointsRequest>
        Model::ListMarketplaceModelEndpointsOutcomeCallable ListMarketplaceModelEndpointsCallable(const ListMarketplaceModelEndpointsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListMarketplaceModelEndpoints, request);
        }
 
        template<typename ListMarketplaceModelEndpointsRequestT = Model::ListMarketplaceModelEndpointsRequest>
        void ListMarketplaceModelEndpointsAsync(const ListMarketplaceModelEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMarketplaceModelEndpointsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListMarketplaceModelEndpoints, request, handler, context);
        }
 
        virtual Model::ListModelCopyJobsOutcome ListModelCopyJobs(const Model::ListModelCopyJobsRequest& request = {}) const;
 
        template<typename ListModelCopyJobsRequestT = Model::ListModelCopyJobsRequest>
        Model::ListModelCopyJobsOutcomeCallable ListModelCopyJobsCallable(const ListModelCopyJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListModelCopyJobs, request);
        }
 
        template<typename ListModelCopyJobsRequestT = Model::ListModelCopyJobsRequest>
        void ListModelCopyJobsAsync(const ListModelCopyJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListModelCopyJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListModelCopyJobs, request, handler, context);
        }
 
        virtual Model::ListModelCustomizationJobsOutcome ListModelCustomizationJobs(const Model::ListModelCustomizationJobsRequest& request = {}) const;
 
        template<typename ListModelCustomizationJobsRequestT = Model::ListModelCustomizationJobsRequest>
        Model::ListModelCustomizationJobsOutcomeCallable ListModelCustomizationJobsCallable(const ListModelCustomizationJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListModelCustomizationJobs, request);
        }
 
        template<typename ListModelCustomizationJobsRequestT = Model::ListModelCustomizationJobsRequest>
        void ListModelCustomizationJobsAsync(const ListModelCustomizationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListModelCustomizationJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListModelCustomizationJobs, request, handler, context);
        }
 
        virtual Model::ListModelImportJobsOutcome ListModelImportJobs(const Model::ListModelImportJobsRequest& request = {}) const;
 
        template<typename ListModelImportJobsRequestT = Model::ListModelImportJobsRequest>
        Model::ListModelImportJobsOutcomeCallable ListModelImportJobsCallable(const ListModelImportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListModelImportJobs, request);
        }
 
        template<typename ListModelImportJobsRequestT = Model::ListModelImportJobsRequest>
        void ListModelImportJobsAsync(const ListModelImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListModelImportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListModelImportJobs, request, handler, context);
        }
 
        virtual Model::ListModelInvocationJobsOutcome ListModelInvocationJobs(const Model::ListModelInvocationJobsRequest& request = {}) const;
 
        template<typename ListModelInvocationJobsRequestT = Model::ListModelInvocationJobsRequest>
        Model::ListModelInvocationJobsOutcomeCallable ListModelInvocationJobsCallable(const ListModelInvocationJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListModelInvocationJobs, request);
        }
 
        template<typename ListModelInvocationJobsRequestT = Model::ListModelInvocationJobsRequest>
        void ListModelInvocationJobsAsync(const ListModelInvocationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListModelInvocationJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListModelInvocationJobs, request, handler, context);
        }
 
        virtual Model::ListPromptRoutersOutcome ListPromptRouters(const Model::ListPromptRoutersRequest& request = {}) const;
 
        template<typename ListPromptRoutersRequestT = Model::ListPromptRoutersRequest>
        Model::ListPromptRoutersOutcomeCallable ListPromptRoutersCallable(const ListPromptRoutersRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListPromptRouters, request);
        }
 
        template<typename ListPromptRoutersRequestT = Model::ListPromptRoutersRequest>
        void ListPromptRoutersAsync(const ListPromptRoutersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPromptRoutersRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListPromptRouters, request, handler, context);
        }
 
        virtual Model::ListProvisionedModelThroughputsOutcome ListProvisionedModelThroughputs(const Model::ListProvisionedModelThroughputsRequest& request = {}) const;
 
        template<typename ListProvisionedModelThroughputsRequestT = Model::ListProvisionedModelThroughputsRequest>
        Model::ListProvisionedModelThroughputsOutcomeCallable ListProvisionedModelThroughputsCallable(const ListProvisionedModelThroughputsRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListProvisionedModelThroughputs, request);
        }
 
        template<typename ListProvisionedModelThroughputsRequestT = Model::ListProvisionedModelThroughputsRequest>
        void ListProvisionedModelThroughputsAsync(const ListProvisionedModelThroughputsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProvisionedModelThroughputsRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListProvisionedModelThroughputs, 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(&BedrockClient::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(&BedrockClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutModelInvocationLoggingConfigurationOutcome PutModelInvocationLoggingConfiguration(const Model::PutModelInvocationLoggingConfigurationRequest& request) const;
 
        template<typename PutModelInvocationLoggingConfigurationRequestT = Model::PutModelInvocationLoggingConfigurationRequest>
        Model::PutModelInvocationLoggingConfigurationOutcomeCallable PutModelInvocationLoggingConfigurationCallable(const PutModelInvocationLoggingConfigurationRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::PutModelInvocationLoggingConfiguration, request);
        }
 
        template<typename PutModelInvocationLoggingConfigurationRequestT = Model::PutModelInvocationLoggingConfigurationRequest>
        void PutModelInvocationLoggingConfigurationAsync(const PutModelInvocationLoggingConfigurationRequestT& request, const PutModelInvocationLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::PutModelInvocationLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::PutUseCaseForModelAccessOutcome PutUseCaseForModelAccess(const Model::PutUseCaseForModelAccessRequest& request) const;
 
        template<typename PutUseCaseForModelAccessRequestT = Model::PutUseCaseForModelAccessRequest>
        Model::PutUseCaseForModelAccessOutcomeCallable PutUseCaseForModelAccessCallable(const PutUseCaseForModelAccessRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::PutUseCaseForModelAccess, request);
        }
 
        template<typename PutUseCaseForModelAccessRequestT = Model::PutUseCaseForModelAccessRequest>
        void PutUseCaseForModelAccessAsync(const PutUseCaseForModelAccessRequestT& request, const PutUseCaseForModelAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::PutUseCaseForModelAccess, request, handler, context);
        }
 
        virtual Model::RegisterMarketplaceModelEndpointOutcome RegisterMarketplaceModelEndpoint(const Model::RegisterMarketplaceModelEndpointRequest& request) const;
 
        template<typename RegisterMarketplaceModelEndpointRequestT = Model::RegisterMarketplaceModelEndpointRequest>
        Model::RegisterMarketplaceModelEndpointOutcomeCallable RegisterMarketplaceModelEndpointCallable(const RegisterMarketplaceModelEndpointRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::RegisterMarketplaceModelEndpoint, request);
        }
 
        template<typename RegisterMarketplaceModelEndpointRequestT = Model::RegisterMarketplaceModelEndpointRequest>
        void RegisterMarketplaceModelEndpointAsync(const RegisterMarketplaceModelEndpointRequestT& request, const RegisterMarketplaceModelEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::RegisterMarketplaceModelEndpoint, request, handler, context);
        }
 
        virtual Model::StopEvaluationJobOutcome StopEvaluationJob(const Model::StopEvaluationJobRequest& request) const;
 
        template<typename StopEvaluationJobRequestT = Model::StopEvaluationJobRequest>
        Model::StopEvaluationJobOutcomeCallable StopEvaluationJobCallable(const StopEvaluationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::StopEvaluationJob, request);
        }
 
        template<typename StopEvaluationJobRequestT = Model::StopEvaluationJobRequest>
        void StopEvaluationJobAsync(const StopEvaluationJobRequestT& request, const StopEvaluationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::StopEvaluationJob, request, handler, context);
        }
 
        virtual Model::StopModelCustomizationJobOutcome StopModelCustomizationJob(const Model::StopModelCustomizationJobRequest& request) const;
 
        template<typename StopModelCustomizationJobRequestT = Model::StopModelCustomizationJobRequest>
        Model::StopModelCustomizationJobOutcomeCallable StopModelCustomizationJobCallable(const StopModelCustomizationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::StopModelCustomizationJob, request);
        }
 
        template<typename StopModelCustomizationJobRequestT = Model::StopModelCustomizationJobRequest>
        void StopModelCustomizationJobAsync(const StopModelCustomizationJobRequestT& request, const StopModelCustomizationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::StopModelCustomizationJob, request, handler, context);
        }
 
        virtual Model::StopModelInvocationJobOutcome StopModelInvocationJob(const Model::StopModelInvocationJobRequest& request) const;
 
        template<typename StopModelInvocationJobRequestT = Model::StopModelInvocationJobRequest>
        Model::StopModelInvocationJobOutcomeCallable StopModelInvocationJobCallable(const StopModelInvocationJobRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::StopModelInvocationJob, request);
        }
 
        template<typename StopModelInvocationJobRequestT = Model::StopModelInvocationJobRequest>
        void StopModelInvocationJobAsync(const StopModelInvocationJobRequestT& request, const StopModelInvocationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::StopModelInvocationJob, 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(&BedrockClient::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(&BedrockClient::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(&BedrockClient::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(&BedrockClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateGuardrailOutcome UpdateGuardrail(const Model::UpdateGuardrailRequest& request) const;
 
        template<typename UpdateGuardrailRequestT = Model::UpdateGuardrailRequest>
        Model::UpdateGuardrailOutcomeCallable UpdateGuardrailCallable(const UpdateGuardrailRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::UpdateGuardrail, request);
        }
 
        template<typename UpdateGuardrailRequestT = Model::UpdateGuardrailRequest>
        void UpdateGuardrailAsync(const UpdateGuardrailRequestT& request, const UpdateGuardrailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::UpdateGuardrail, request, handler, context);
        }
 
        virtual Model::UpdateMarketplaceModelEndpointOutcome UpdateMarketplaceModelEndpoint(const Model::UpdateMarketplaceModelEndpointRequest& request) const;
 
        template<typename UpdateMarketplaceModelEndpointRequestT = Model::UpdateMarketplaceModelEndpointRequest>
        Model::UpdateMarketplaceModelEndpointOutcomeCallable UpdateMarketplaceModelEndpointCallable(const UpdateMarketplaceModelEndpointRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::UpdateMarketplaceModelEndpoint, request);
        }
 
        template<typename UpdateMarketplaceModelEndpointRequestT = Model::UpdateMarketplaceModelEndpointRequest>
        void UpdateMarketplaceModelEndpointAsync(const UpdateMarketplaceModelEndpointRequestT& request, const UpdateMarketplaceModelEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::UpdateMarketplaceModelEndpoint, request, handler, context);
        }
 
        virtual Model::UpdateProvisionedModelThroughputOutcome UpdateProvisionedModelThroughput(const Model::UpdateProvisionedModelThroughputRequest& request) const;
 
        template<typename UpdateProvisionedModelThroughputRequestT = Model::UpdateProvisionedModelThroughputRequest>
        Model::UpdateProvisionedModelThroughputOutcomeCallable UpdateProvisionedModelThroughputCallable(const UpdateProvisionedModelThroughputRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::UpdateProvisionedModelThroughput, request);
        }
 
        template<typename UpdateProvisionedModelThroughputRequestT = Model::UpdateProvisionedModelThroughputRequest>
        void UpdateProvisionedModelThroughputAsync(const UpdateProvisionedModelThroughputRequestT& request, const UpdateProvisionedModelThroughputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::UpdateProvisionedModelThroughput, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BedrockEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BedrockClient>;
      void init(const BedrockClientConfiguration& clientConfiguration);
 
      BedrockClientConfiguration m_clientConfiguration;
      std::shared_ptr<BedrockEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Bedrock
} // namespace Aws