BedrockClient.h

 
#pragma once
#include <aws/bedrock/BedrockErrorMarshaller.h>
#include <aws/bedrock/BedrockPaginationBase.h>
#include <aws/bedrock/BedrockServiceClientModel.h>
#include <aws/bedrock/Bedrock_EXPORTS.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <smithy/client/AwsSmithyClient.h>
#include <smithy/client/serializer/JsonOutcomeSerializer.h>
#include <smithy/identity/auth/built-in/BearerTokenAuthScheme.h>
#include <smithy/identity/auth/built-in/GenericAuthSchemeResolver.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
 
namespace Aws {
namespace Bedrock {
AWS_BEDROCK_API extern const char SERVICE_NAME[];
class AWS_BEDROCK_API BedrockClient
    : Aws::Client::ClientWithAsyncTemplateMethods<BedrockClient>,
      public smithy::client::AwsSmithyClientT<
          Aws::Bedrock::SERVICE_NAME, Aws::Bedrock::BedrockClientConfiguration, smithy::AuthSchemeResolverBase<>,
          Aws::Crt::Variant<smithy::SigV4AuthScheme, smithy::BearerTokenAuthScheme>, BedrockEndpointProviderBase,
          smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockErrorMarshaller>,
      public BedrockPaginationBase<BedrockClient> {
 public:
  static const char* GetServiceName();
  static const char* GetAllocationTag();
  inline const char* GetServiceClientName() const override { return "Bedrock"; }
 
  typedef BedrockClientConfiguration ClientConfigurationType;
  typedef BedrockEndpointProvider EndpointProviderType;
 
  BedrockClient(
      const Aws::UnorderedMap<Aws::String, Aws::Crt::Variant<smithy::SigV4AuthScheme, smithy::BearerTokenAuthScheme>> authSchemeMap,
      std::shared_ptr<BedrockEndpointProviderBase> endpointProvider = nullptr,
      const Aws::Bedrock::BedrockClientConfiguration& clientConfiguration = Aws::Bedrock::BedrockClientConfiguration());
  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::DeleteEnforcedGuardrailConfigurationOutcome DeleteEnforcedGuardrailConfiguration(
      const Model::DeleteEnforcedGuardrailConfigurationRequest& request) const;
 
  template <typename DeleteEnforcedGuardrailConfigurationRequestT = Model::DeleteEnforcedGuardrailConfigurationRequest>
  Model::DeleteEnforcedGuardrailConfigurationOutcomeCallable DeleteEnforcedGuardrailConfigurationCallable(
      const DeleteEnforcedGuardrailConfigurationRequestT& request) const {
    return SubmitCallable(&BedrockClient::DeleteEnforcedGuardrailConfiguration, request);
  }
 
  template <typename DeleteEnforcedGuardrailConfigurationRequestT = Model::DeleteEnforcedGuardrailConfigurationRequest>
  void DeleteEnforcedGuardrailConfigurationAsync(const DeleteEnforcedGuardrailConfigurationRequestT& request,
                                                 const DeleteEnforcedGuardrailConfigurationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockClient::DeleteEnforcedGuardrailConfiguration, 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::ListEnforcedGuardrailsConfigurationOutcome ListEnforcedGuardrailsConfiguration(
      const Model::ListEnforcedGuardrailsConfigurationRequest& request = {}) const;
 
  template <typename ListEnforcedGuardrailsConfigurationRequestT = Model::ListEnforcedGuardrailsConfigurationRequest>
  Model::ListEnforcedGuardrailsConfigurationOutcomeCallable ListEnforcedGuardrailsConfigurationCallable(
      const ListEnforcedGuardrailsConfigurationRequestT& request = {}) const {
    return SubmitCallable(&BedrockClient::ListEnforcedGuardrailsConfiguration, request);
  }
 
  template <typename ListEnforcedGuardrailsConfigurationRequestT = Model::ListEnforcedGuardrailsConfigurationRequest>
  void ListEnforcedGuardrailsConfigurationAsync(const ListEnforcedGuardrailsConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const ListEnforcedGuardrailsConfigurationRequestT& request = {}) const {
    return SubmitAsync(&BedrockClient::ListEnforcedGuardrailsConfiguration, 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::PutEnforcedGuardrailConfigurationOutcome PutEnforcedGuardrailConfiguration(
      const Model::PutEnforcedGuardrailConfigurationRequest& request) const;
 
  template <typename PutEnforcedGuardrailConfigurationRequestT = Model::PutEnforcedGuardrailConfigurationRequest>
  Model::PutEnforcedGuardrailConfigurationOutcomeCallable PutEnforcedGuardrailConfigurationCallable(
      const PutEnforcedGuardrailConfigurationRequestT& request) const {
    return SubmitCallable(&BedrockClient::PutEnforcedGuardrailConfiguration, request);
  }
 
  template <typename PutEnforcedGuardrailConfigurationRequestT = Model::PutEnforcedGuardrailConfigurationRequest>
  void PutEnforcedGuardrailConfigurationAsync(const PutEnforcedGuardrailConfigurationRequestT& request,
                                              const PutEnforcedGuardrailConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockClient::PutEnforcedGuardrailConfiguration, 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::UpdateCustomModelDeploymentOutcome UpdateCustomModelDeployment(
      const Model::UpdateCustomModelDeploymentRequest& request) const;
 
  template <typename UpdateCustomModelDeploymentRequestT = Model::UpdateCustomModelDeploymentRequest>
  Model::UpdateCustomModelDeploymentOutcomeCallable UpdateCustomModelDeploymentCallable(
      const UpdateCustomModelDeploymentRequestT& request) const {
    return SubmitCallable(&BedrockClient::UpdateCustomModelDeployment, request);
  }
 
  template <typename UpdateCustomModelDeploymentRequestT = Model::UpdateCustomModelDeploymentRequest>
  void UpdateCustomModelDeploymentAsync(const UpdateCustomModelDeploymentRequestT& request,
                                        const UpdateCustomModelDeploymentResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BedrockClient::UpdateCustomModelDeployment, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<BedrockEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BedrockClient>;
};
 
}  // namespace Bedrock
}  // namespace Aws