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::CancelAutomatedReasoningPolicyBuildWorkflowOutcome CancelAutomatedReasoningPolicyBuildWorkflow(const Model::CancelAutomatedReasoningPolicyBuildWorkflowRequest& request) const;
 
        template<typename CancelAutomatedReasoningPolicyBuildWorkflowRequestT = Model::CancelAutomatedReasoningPolicyBuildWorkflowRequest>
        Model::CancelAutomatedReasoningPolicyBuildWorkflowOutcomeCallable CancelAutomatedReasoningPolicyBuildWorkflowCallable(const CancelAutomatedReasoningPolicyBuildWorkflowRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CancelAutomatedReasoningPolicyBuildWorkflow, request);
        }
 
        template<typename CancelAutomatedReasoningPolicyBuildWorkflowRequestT = Model::CancelAutomatedReasoningPolicyBuildWorkflowRequest>
        void CancelAutomatedReasoningPolicyBuildWorkflowAsync(const CancelAutomatedReasoningPolicyBuildWorkflowRequestT& request, const CancelAutomatedReasoningPolicyBuildWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CancelAutomatedReasoningPolicyBuildWorkflow, request, handler, context);
        }
 
        virtual Model::CreateAutomatedReasoningPolicyOutcome CreateAutomatedReasoningPolicy(const Model::CreateAutomatedReasoningPolicyRequest& request) const;
 
        template<typename CreateAutomatedReasoningPolicyRequestT = Model::CreateAutomatedReasoningPolicyRequest>
        Model::CreateAutomatedReasoningPolicyOutcomeCallable CreateAutomatedReasoningPolicyCallable(const CreateAutomatedReasoningPolicyRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateAutomatedReasoningPolicy, request);
        }
 
        template<typename CreateAutomatedReasoningPolicyRequestT = Model::CreateAutomatedReasoningPolicyRequest>
        void CreateAutomatedReasoningPolicyAsync(const CreateAutomatedReasoningPolicyRequestT& request, const CreateAutomatedReasoningPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateAutomatedReasoningPolicy, request, handler, context);
        }
 
        virtual Model::CreateAutomatedReasoningPolicyTestCaseOutcome CreateAutomatedReasoningPolicyTestCase(const Model::CreateAutomatedReasoningPolicyTestCaseRequest& request) const;
 
        template<typename CreateAutomatedReasoningPolicyTestCaseRequestT = Model::CreateAutomatedReasoningPolicyTestCaseRequest>
        Model::CreateAutomatedReasoningPolicyTestCaseOutcomeCallable CreateAutomatedReasoningPolicyTestCaseCallable(const CreateAutomatedReasoningPolicyTestCaseRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateAutomatedReasoningPolicyTestCase, request);
        }
 
        template<typename CreateAutomatedReasoningPolicyTestCaseRequestT = Model::CreateAutomatedReasoningPolicyTestCaseRequest>
        void CreateAutomatedReasoningPolicyTestCaseAsync(const CreateAutomatedReasoningPolicyTestCaseRequestT& request, const CreateAutomatedReasoningPolicyTestCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateAutomatedReasoningPolicyTestCase, request, handler, context);
        }
 
        virtual Model::CreateAutomatedReasoningPolicyVersionOutcome CreateAutomatedReasoningPolicyVersion(const Model::CreateAutomatedReasoningPolicyVersionRequest& request) const;
 
        template<typename CreateAutomatedReasoningPolicyVersionRequestT = Model::CreateAutomatedReasoningPolicyVersionRequest>
        Model::CreateAutomatedReasoningPolicyVersionOutcomeCallable CreateAutomatedReasoningPolicyVersionCallable(const CreateAutomatedReasoningPolicyVersionRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::CreateAutomatedReasoningPolicyVersion, request);
        }
 
        template<typename CreateAutomatedReasoningPolicyVersionRequestT = Model::CreateAutomatedReasoningPolicyVersionRequest>
        void CreateAutomatedReasoningPolicyVersionAsync(const CreateAutomatedReasoningPolicyVersionRequestT& request, const CreateAutomatedReasoningPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::CreateAutomatedReasoningPolicyVersion, 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::DeleteAutomatedReasoningPolicyOutcome DeleteAutomatedReasoningPolicy(const Model::DeleteAutomatedReasoningPolicyRequest& request) const;
 
        template<typename DeleteAutomatedReasoningPolicyRequestT = Model::DeleteAutomatedReasoningPolicyRequest>
        Model::DeleteAutomatedReasoningPolicyOutcomeCallable DeleteAutomatedReasoningPolicyCallable(const DeleteAutomatedReasoningPolicyRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteAutomatedReasoningPolicy, request);
        }
 
        template<typename DeleteAutomatedReasoningPolicyRequestT = Model::DeleteAutomatedReasoningPolicyRequest>
        void DeleteAutomatedReasoningPolicyAsync(const DeleteAutomatedReasoningPolicyRequestT& request, const DeleteAutomatedReasoningPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteAutomatedReasoningPolicy, request, handler, context);
        }
 
        virtual Model::DeleteAutomatedReasoningPolicyBuildWorkflowOutcome DeleteAutomatedReasoningPolicyBuildWorkflow(const Model::DeleteAutomatedReasoningPolicyBuildWorkflowRequest& request) const;
 
        template<typename DeleteAutomatedReasoningPolicyBuildWorkflowRequestT = Model::DeleteAutomatedReasoningPolicyBuildWorkflowRequest>
        Model::DeleteAutomatedReasoningPolicyBuildWorkflowOutcomeCallable DeleteAutomatedReasoningPolicyBuildWorkflowCallable(const DeleteAutomatedReasoningPolicyBuildWorkflowRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteAutomatedReasoningPolicyBuildWorkflow, request);
        }
 
        template<typename DeleteAutomatedReasoningPolicyBuildWorkflowRequestT = Model::DeleteAutomatedReasoningPolicyBuildWorkflowRequest>
        void DeleteAutomatedReasoningPolicyBuildWorkflowAsync(const DeleteAutomatedReasoningPolicyBuildWorkflowRequestT& request, const DeleteAutomatedReasoningPolicyBuildWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteAutomatedReasoningPolicyBuildWorkflow, request, handler, context);
        }
 
        virtual Model::DeleteAutomatedReasoningPolicyTestCaseOutcome DeleteAutomatedReasoningPolicyTestCase(const Model::DeleteAutomatedReasoningPolicyTestCaseRequest& request) const;
 
        template<typename DeleteAutomatedReasoningPolicyTestCaseRequestT = Model::DeleteAutomatedReasoningPolicyTestCaseRequest>
        Model::DeleteAutomatedReasoningPolicyTestCaseOutcomeCallable DeleteAutomatedReasoningPolicyTestCaseCallable(const DeleteAutomatedReasoningPolicyTestCaseRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::DeleteAutomatedReasoningPolicyTestCase, request);
        }
 
        template<typename DeleteAutomatedReasoningPolicyTestCaseRequestT = Model::DeleteAutomatedReasoningPolicyTestCaseRequest>
        void DeleteAutomatedReasoningPolicyTestCaseAsync(const DeleteAutomatedReasoningPolicyTestCaseRequestT& request, const DeleteAutomatedReasoningPolicyTestCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::DeleteAutomatedReasoningPolicyTestCase, 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::ExportAutomatedReasoningPolicyVersionOutcome ExportAutomatedReasoningPolicyVersion(const Model::ExportAutomatedReasoningPolicyVersionRequest& request) const;
 
        template<typename ExportAutomatedReasoningPolicyVersionRequestT = Model::ExportAutomatedReasoningPolicyVersionRequest>
        Model::ExportAutomatedReasoningPolicyVersionOutcomeCallable ExportAutomatedReasoningPolicyVersionCallable(const ExportAutomatedReasoningPolicyVersionRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::ExportAutomatedReasoningPolicyVersion, request);
        }
 
        template<typename ExportAutomatedReasoningPolicyVersionRequestT = Model::ExportAutomatedReasoningPolicyVersionRequest>
        void ExportAutomatedReasoningPolicyVersionAsync(const ExportAutomatedReasoningPolicyVersionRequestT& request, const ExportAutomatedReasoningPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::ExportAutomatedReasoningPolicyVersion, request, handler, context);
        }
 
        virtual Model::GetAutomatedReasoningPolicyOutcome GetAutomatedReasoningPolicy(const Model::GetAutomatedReasoningPolicyRequest& request) const;
 
        template<typename GetAutomatedReasoningPolicyRequestT = Model::GetAutomatedReasoningPolicyRequest>
        Model::GetAutomatedReasoningPolicyOutcomeCallable GetAutomatedReasoningPolicyCallable(const GetAutomatedReasoningPolicyRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetAutomatedReasoningPolicy, request);
        }
 
        template<typename GetAutomatedReasoningPolicyRequestT = Model::GetAutomatedReasoningPolicyRequest>
        void GetAutomatedReasoningPolicyAsync(const GetAutomatedReasoningPolicyRequestT& request, const GetAutomatedReasoningPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetAutomatedReasoningPolicy, request, handler, context);
        }
 
        virtual Model::GetAutomatedReasoningPolicyAnnotationsOutcome GetAutomatedReasoningPolicyAnnotations(const Model::GetAutomatedReasoningPolicyAnnotationsRequest& request) const;
 
        template<typename GetAutomatedReasoningPolicyAnnotationsRequestT = Model::GetAutomatedReasoningPolicyAnnotationsRequest>
        Model::GetAutomatedReasoningPolicyAnnotationsOutcomeCallable GetAutomatedReasoningPolicyAnnotationsCallable(const GetAutomatedReasoningPolicyAnnotationsRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetAutomatedReasoningPolicyAnnotations, request);
        }
 
        template<typename GetAutomatedReasoningPolicyAnnotationsRequestT = Model::GetAutomatedReasoningPolicyAnnotationsRequest>
        void GetAutomatedReasoningPolicyAnnotationsAsync(const GetAutomatedReasoningPolicyAnnotationsRequestT& request, const GetAutomatedReasoningPolicyAnnotationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetAutomatedReasoningPolicyAnnotations, request, handler, context);
        }
 
        virtual Model::GetAutomatedReasoningPolicyBuildWorkflowOutcome GetAutomatedReasoningPolicyBuildWorkflow(const Model::GetAutomatedReasoningPolicyBuildWorkflowRequest& request) const;
 
        template<typename GetAutomatedReasoningPolicyBuildWorkflowRequestT = Model::GetAutomatedReasoningPolicyBuildWorkflowRequest>
        Model::GetAutomatedReasoningPolicyBuildWorkflowOutcomeCallable GetAutomatedReasoningPolicyBuildWorkflowCallable(const GetAutomatedReasoningPolicyBuildWorkflowRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetAutomatedReasoningPolicyBuildWorkflow, request);
        }
 
        template<typename GetAutomatedReasoningPolicyBuildWorkflowRequestT = Model::GetAutomatedReasoningPolicyBuildWorkflowRequest>
        void GetAutomatedReasoningPolicyBuildWorkflowAsync(const GetAutomatedReasoningPolicyBuildWorkflowRequestT& request, const GetAutomatedReasoningPolicyBuildWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetAutomatedReasoningPolicyBuildWorkflow, request, handler, context);
        }
 
        virtual Model::GetAutomatedReasoningPolicyBuildWorkflowResultAssetsOutcome GetAutomatedReasoningPolicyBuildWorkflowResultAssets(const Model::GetAutomatedReasoningPolicyBuildWorkflowResultAssetsRequest& request) const;
 
        template<typename GetAutomatedReasoningPolicyBuildWorkflowResultAssetsRequestT = Model::GetAutomatedReasoningPolicyBuildWorkflowResultAssetsRequest>
        Model::GetAutomatedReasoningPolicyBuildWorkflowResultAssetsOutcomeCallable GetAutomatedReasoningPolicyBuildWorkflowResultAssetsCallable(const GetAutomatedReasoningPolicyBuildWorkflowResultAssetsRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetAutomatedReasoningPolicyBuildWorkflowResultAssets, request);
        }
 
        template<typename GetAutomatedReasoningPolicyBuildWorkflowResultAssetsRequestT = Model::GetAutomatedReasoningPolicyBuildWorkflowResultAssetsRequest>
        void GetAutomatedReasoningPolicyBuildWorkflowResultAssetsAsync(const GetAutomatedReasoningPolicyBuildWorkflowResultAssetsRequestT& request, const GetAutomatedReasoningPolicyBuildWorkflowResultAssetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetAutomatedReasoningPolicyBuildWorkflowResultAssets, request, handler, context);
        }
 
        virtual Model::GetAutomatedReasoningPolicyNextScenarioOutcome GetAutomatedReasoningPolicyNextScenario(const Model::GetAutomatedReasoningPolicyNextScenarioRequest& request) const;
 
        template<typename GetAutomatedReasoningPolicyNextScenarioRequestT = Model::GetAutomatedReasoningPolicyNextScenarioRequest>
        Model::GetAutomatedReasoningPolicyNextScenarioOutcomeCallable GetAutomatedReasoningPolicyNextScenarioCallable(const GetAutomatedReasoningPolicyNextScenarioRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetAutomatedReasoningPolicyNextScenario, request);
        }
 
        template<typename GetAutomatedReasoningPolicyNextScenarioRequestT = Model::GetAutomatedReasoningPolicyNextScenarioRequest>
        void GetAutomatedReasoningPolicyNextScenarioAsync(const GetAutomatedReasoningPolicyNextScenarioRequestT& request, const GetAutomatedReasoningPolicyNextScenarioResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetAutomatedReasoningPolicyNextScenario, request, handler, context);
        }
 
        virtual Model::GetAutomatedReasoningPolicyTestCaseOutcome GetAutomatedReasoningPolicyTestCase(const Model::GetAutomatedReasoningPolicyTestCaseRequest& request) const;
 
        template<typename GetAutomatedReasoningPolicyTestCaseRequestT = Model::GetAutomatedReasoningPolicyTestCaseRequest>
        Model::GetAutomatedReasoningPolicyTestCaseOutcomeCallable GetAutomatedReasoningPolicyTestCaseCallable(const GetAutomatedReasoningPolicyTestCaseRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetAutomatedReasoningPolicyTestCase, request);
        }
 
        template<typename GetAutomatedReasoningPolicyTestCaseRequestT = Model::GetAutomatedReasoningPolicyTestCaseRequest>
        void GetAutomatedReasoningPolicyTestCaseAsync(const GetAutomatedReasoningPolicyTestCaseRequestT& request, const GetAutomatedReasoningPolicyTestCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetAutomatedReasoningPolicyTestCase, request, handler, context);
        }
 
        virtual Model::GetAutomatedReasoningPolicyTestResultOutcome GetAutomatedReasoningPolicyTestResult(const Model::GetAutomatedReasoningPolicyTestResultRequest& request) const;
 
        template<typename GetAutomatedReasoningPolicyTestResultRequestT = Model::GetAutomatedReasoningPolicyTestResultRequest>
        Model::GetAutomatedReasoningPolicyTestResultOutcomeCallable GetAutomatedReasoningPolicyTestResultCallable(const GetAutomatedReasoningPolicyTestResultRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::GetAutomatedReasoningPolicyTestResult, request);
        }
 
        template<typename GetAutomatedReasoningPolicyTestResultRequestT = Model::GetAutomatedReasoningPolicyTestResultRequest>
        void GetAutomatedReasoningPolicyTestResultAsync(const GetAutomatedReasoningPolicyTestResultRequestT& request, const GetAutomatedReasoningPolicyTestResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::GetAutomatedReasoningPolicyTestResult, 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::ListAutomatedReasoningPoliciesOutcome ListAutomatedReasoningPolicies(const Model::ListAutomatedReasoningPoliciesRequest& request = {}) const;
 
        template<typename ListAutomatedReasoningPoliciesRequestT = Model::ListAutomatedReasoningPoliciesRequest>
        Model::ListAutomatedReasoningPoliciesOutcomeCallable ListAutomatedReasoningPoliciesCallable(const ListAutomatedReasoningPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&BedrockClient::ListAutomatedReasoningPolicies, request);
        }
 
        template<typename ListAutomatedReasoningPoliciesRequestT = Model::ListAutomatedReasoningPoliciesRequest>
        void ListAutomatedReasoningPoliciesAsync(const ListAutomatedReasoningPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAutomatedReasoningPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&BedrockClient::ListAutomatedReasoningPolicies, request, handler, context);
        }
 
        virtual Model::ListAutomatedReasoningPolicyBuildWorkflowsOutcome ListAutomatedReasoningPolicyBuildWorkflows(const Model::ListAutomatedReasoningPolicyBuildWorkflowsRequest& request) const;
 
        template<typename ListAutomatedReasoningPolicyBuildWorkflowsRequestT = Model::ListAutomatedReasoningPolicyBuildWorkflowsRequest>
        Model::ListAutomatedReasoningPolicyBuildWorkflowsOutcomeCallable ListAutomatedReasoningPolicyBuildWorkflowsCallable(const ListAutomatedReasoningPolicyBuildWorkflowsRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::ListAutomatedReasoningPolicyBuildWorkflows, request);
        }
 
        template<typename ListAutomatedReasoningPolicyBuildWorkflowsRequestT = Model::ListAutomatedReasoningPolicyBuildWorkflowsRequest>
        void ListAutomatedReasoningPolicyBuildWorkflowsAsync(const ListAutomatedReasoningPolicyBuildWorkflowsRequestT& request, const ListAutomatedReasoningPolicyBuildWorkflowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::ListAutomatedReasoningPolicyBuildWorkflows, request, handler, context);
        }
 
        virtual Model::ListAutomatedReasoningPolicyTestCasesOutcome ListAutomatedReasoningPolicyTestCases(const Model::ListAutomatedReasoningPolicyTestCasesRequest& request) const;
 
        template<typename ListAutomatedReasoningPolicyTestCasesRequestT = Model::ListAutomatedReasoningPolicyTestCasesRequest>
        Model::ListAutomatedReasoningPolicyTestCasesOutcomeCallable ListAutomatedReasoningPolicyTestCasesCallable(const ListAutomatedReasoningPolicyTestCasesRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::ListAutomatedReasoningPolicyTestCases, request);
        }
 
        template<typename ListAutomatedReasoningPolicyTestCasesRequestT = Model::ListAutomatedReasoningPolicyTestCasesRequest>
        void ListAutomatedReasoningPolicyTestCasesAsync(const ListAutomatedReasoningPolicyTestCasesRequestT& request, const ListAutomatedReasoningPolicyTestCasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::ListAutomatedReasoningPolicyTestCases, request, handler, context);
        }
 
        virtual Model::ListAutomatedReasoningPolicyTestResultsOutcome ListAutomatedReasoningPolicyTestResults(const Model::ListAutomatedReasoningPolicyTestResultsRequest& request) const;
 
        template<typename ListAutomatedReasoningPolicyTestResultsRequestT = Model::ListAutomatedReasoningPolicyTestResultsRequest>
        Model::ListAutomatedReasoningPolicyTestResultsOutcomeCallable ListAutomatedReasoningPolicyTestResultsCallable(const ListAutomatedReasoningPolicyTestResultsRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::ListAutomatedReasoningPolicyTestResults, request);
        }
 
        template<typename ListAutomatedReasoningPolicyTestResultsRequestT = Model::ListAutomatedReasoningPolicyTestResultsRequest>
        void ListAutomatedReasoningPolicyTestResultsAsync(const ListAutomatedReasoningPolicyTestResultsRequestT& request, const ListAutomatedReasoningPolicyTestResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::ListAutomatedReasoningPolicyTestResults, 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::StartAutomatedReasoningPolicyBuildWorkflowOutcome StartAutomatedReasoningPolicyBuildWorkflow(const Model::StartAutomatedReasoningPolicyBuildWorkflowRequest& request) const;
 
        template<typename StartAutomatedReasoningPolicyBuildWorkflowRequestT = Model::StartAutomatedReasoningPolicyBuildWorkflowRequest>
        Model::StartAutomatedReasoningPolicyBuildWorkflowOutcomeCallable StartAutomatedReasoningPolicyBuildWorkflowCallable(const StartAutomatedReasoningPolicyBuildWorkflowRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::StartAutomatedReasoningPolicyBuildWorkflow, request);
        }
 
        template<typename StartAutomatedReasoningPolicyBuildWorkflowRequestT = Model::StartAutomatedReasoningPolicyBuildWorkflowRequest>
        void StartAutomatedReasoningPolicyBuildWorkflowAsync(const StartAutomatedReasoningPolicyBuildWorkflowRequestT& request, const StartAutomatedReasoningPolicyBuildWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::StartAutomatedReasoningPolicyBuildWorkflow, request, handler, context);
        }
 
        virtual Model::StartAutomatedReasoningPolicyTestWorkflowOutcome StartAutomatedReasoningPolicyTestWorkflow(const Model::StartAutomatedReasoningPolicyTestWorkflowRequest& request) const;
 
        template<typename StartAutomatedReasoningPolicyTestWorkflowRequestT = Model::StartAutomatedReasoningPolicyTestWorkflowRequest>
        Model::StartAutomatedReasoningPolicyTestWorkflowOutcomeCallable StartAutomatedReasoningPolicyTestWorkflowCallable(const StartAutomatedReasoningPolicyTestWorkflowRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::StartAutomatedReasoningPolicyTestWorkflow, request);
        }
 
        template<typename StartAutomatedReasoningPolicyTestWorkflowRequestT = Model::StartAutomatedReasoningPolicyTestWorkflowRequest>
        void StartAutomatedReasoningPolicyTestWorkflowAsync(const StartAutomatedReasoningPolicyTestWorkflowRequestT& request, const StartAutomatedReasoningPolicyTestWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::StartAutomatedReasoningPolicyTestWorkflow, 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::UpdateAutomatedReasoningPolicyOutcome UpdateAutomatedReasoningPolicy(const Model::UpdateAutomatedReasoningPolicyRequest& request) const;
 
        template<typename UpdateAutomatedReasoningPolicyRequestT = Model::UpdateAutomatedReasoningPolicyRequest>
        Model::UpdateAutomatedReasoningPolicyOutcomeCallable UpdateAutomatedReasoningPolicyCallable(const UpdateAutomatedReasoningPolicyRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::UpdateAutomatedReasoningPolicy, request);
        }
 
        template<typename UpdateAutomatedReasoningPolicyRequestT = Model::UpdateAutomatedReasoningPolicyRequest>
        void UpdateAutomatedReasoningPolicyAsync(const UpdateAutomatedReasoningPolicyRequestT& request, const UpdateAutomatedReasoningPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::UpdateAutomatedReasoningPolicy, request, handler, context);
        }
 
        virtual Model::UpdateAutomatedReasoningPolicyAnnotationsOutcome UpdateAutomatedReasoningPolicyAnnotations(const Model::UpdateAutomatedReasoningPolicyAnnotationsRequest& request) const;
 
        template<typename UpdateAutomatedReasoningPolicyAnnotationsRequestT = Model::UpdateAutomatedReasoningPolicyAnnotationsRequest>
        Model::UpdateAutomatedReasoningPolicyAnnotationsOutcomeCallable UpdateAutomatedReasoningPolicyAnnotationsCallable(const UpdateAutomatedReasoningPolicyAnnotationsRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::UpdateAutomatedReasoningPolicyAnnotations, request);
        }
 
        template<typename UpdateAutomatedReasoningPolicyAnnotationsRequestT = Model::UpdateAutomatedReasoningPolicyAnnotationsRequest>
        void UpdateAutomatedReasoningPolicyAnnotationsAsync(const UpdateAutomatedReasoningPolicyAnnotationsRequestT& request, const UpdateAutomatedReasoningPolicyAnnotationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::UpdateAutomatedReasoningPolicyAnnotations, request, handler, context);
        }
 
        virtual Model::UpdateAutomatedReasoningPolicyTestCaseOutcome UpdateAutomatedReasoningPolicyTestCase(const Model::UpdateAutomatedReasoningPolicyTestCaseRequest& request) const;
 
        template<typename UpdateAutomatedReasoningPolicyTestCaseRequestT = Model::UpdateAutomatedReasoningPolicyTestCaseRequest>
        Model::UpdateAutomatedReasoningPolicyTestCaseOutcomeCallable UpdateAutomatedReasoningPolicyTestCaseCallable(const UpdateAutomatedReasoningPolicyTestCaseRequestT& request) const
        {
            return SubmitCallable(&BedrockClient::UpdateAutomatedReasoningPolicyTestCase, request);
        }
 
        template<typename UpdateAutomatedReasoningPolicyTestCaseRequestT = Model::UpdateAutomatedReasoningPolicyTestCaseRequest>
        void UpdateAutomatedReasoningPolicyTestCaseAsync(const UpdateAutomatedReasoningPolicyTestCaseRequestT& request, const UpdateAutomatedReasoningPolicyTestCaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BedrockClient::UpdateAutomatedReasoningPolicyTestCase, 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