SageMakerClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/sagemaker/SageMakerServiceClientModel.h>
#include <aws/sagemaker/SageMaker_EXPORTS.h>
 
namespace Aws {
namespace SageMaker {
class AWS_SAGEMAKER_API SageMakerClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<SageMakerClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SageMakerClientConfiguration ClientConfigurationType;
  typedef SageMakerEndpointProvider EndpointProviderType;
 
  SageMakerClient(const Aws::SageMaker::SageMakerClientConfiguration& clientConfiguration = Aws::SageMaker::SageMakerClientConfiguration(),
                  std::shared_ptr<SageMakerEndpointProviderBase> endpointProvider = nullptr);
 
  SageMakerClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SageMakerEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SageMaker::SageMakerClientConfiguration& clientConfiguration = Aws::SageMaker::SageMakerClientConfiguration());
 
  SageMakerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<SageMakerEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SageMaker::SageMakerClientConfiguration& clientConfiguration = Aws::SageMaker::SageMakerClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SageMakerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SageMakerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SageMakerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SageMakerClient();
 
  virtual Model::AddAssociationOutcome AddAssociation(const Model::AddAssociationRequest& request) const;
 
  template <typename AddAssociationRequestT = Model::AddAssociationRequest>
  Model::AddAssociationOutcomeCallable AddAssociationCallable(const AddAssociationRequestT& request) const {
    return SubmitCallable(&SageMakerClient::AddAssociation, request);
  }
 
  template <typename AddAssociationRequestT = Model::AddAssociationRequest>
  void AddAssociationAsync(const AddAssociationRequestT& request, const AddAssociationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::AddAssociation, request, handler, context);
  }
 
  virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const;
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::AddTags, request);
  }
 
  template <typename AddTagsRequestT = Model::AddTagsRequest>
  void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::AddTags, request, handler, context);
  }
 
  virtual Model::AssociateTrialComponentOutcome AssociateTrialComponent(const Model::AssociateTrialComponentRequest& request) const;
 
  template <typename AssociateTrialComponentRequestT = Model::AssociateTrialComponentRequest>
  Model::AssociateTrialComponentOutcomeCallable AssociateTrialComponentCallable(const AssociateTrialComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::AssociateTrialComponent, request);
  }
 
  template <typename AssociateTrialComponentRequestT = Model::AssociateTrialComponentRequest>
  void AssociateTrialComponentAsync(const AssociateTrialComponentRequestT& request,
                                    const AssociateTrialComponentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::AssociateTrialComponent, request, handler, context);
  }
 
  virtual Model::AttachClusterNodeVolumeOutcome AttachClusterNodeVolume(const Model::AttachClusterNodeVolumeRequest& request) const;
 
  template <typename AttachClusterNodeVolumeRequestT = Model::AttachClusterNodeVolumeRequest>
  Model::AttachClusterNodeVolumeOutcomeCallable AttachClusterNodeVolumeCallable(const AttachClusterNodeVolumeRequestT& request) const {
    return SubmitCallable(&SageMakerClient::AttachClusterNodeVolume, request);
  }
 
  template <typename AttachClusterNodeVolumeRequestT = Model::AttachClusterNodeVolumeRequest>
  void AttachClusterNodeVolumeAsync(const AttachClusterNodeVolumeRequestT& request,
                                    const AttachClusterNodeVolumeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::AttachClusterNodeVolume, request, handler, context);
  }
 
  virtual Model::BatchAddClusterNodesOutcome BatchAddClusterNodes(const Model::BatchAddClusterNodesRequest& request) const;
 
  template <typename BatchAddClusterNodesRequestT = Model::BatchAddClusterNodesRequest>
  Model::BatchAddClusterNodesOutcomeCallable BatchAddClusterNodesCallable(const BatchAddClusterNodesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::BatchAddClusterNodes, request);
  }
 
  template <typename BatchAddClusterNodesRequestT = Model::BatchAddClusterNodesRequest>
  void BatchAddClusterNodesAsync(const BatchAddClusterNodesRequestT& request, const BatchAddClusterNodesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::BatchAddClusterNodes, request, handler, context);
  }
 
  virtual Model::BatchDeleteClusterNodesOutcome BatchDeleteClusterNodes(const Model::BatchDeleteClusterNodesRequest& request) const;
 
  template <typename BatchDeleteClusterNodesRequestT = Model::BatchDeleteClusterNodesRequest>
  Model::BatchDeleteClusterNodesOutcomeCallable BatchDeleteClusterNodesCallable(const BatchDeleteClusterNodesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::BatchDeleteClusterNodes, request);
  }
 
  template <typename BatchDeleteClusterNodesRequestT = Model::BatchDeleteClusterNodesRequest>
  void BatchDeleteClusterNodesAsync(const BatchDeleteClusterNodesRequestT& request,
                                    const BatchDeleteClusterNodesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::BatchDeleteClusterNodes, request, handler, context);
  }
 
  virtual Model::BatchDescribeModelPackageOutcome BatchDescribeModelPackage(const Model::BatchDescribeModelPackageRequest& request) const;
 
  template <typename BatchDescribeModelPackageRequestT = Model::BatchDescribeModelPackageRequest>
  Model::BatchDescribeModelPackageOutcomeCallable BatchDescribeModelPackageCallable(
      const BatchDescribeModelPackageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::BatchDescribeModelPackage, request);
  }
 
  template <typename BatchDescribeModelPackageRequestT = Model::BatchDescribeModelPackageRequest>
  void BatchDescribeModelPackageAsync(const BatchDescribeModelPackageRequestT& request,
                                      const BatchDescribeModelPackageResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::BatchDescribeModelPackage, request, handler, context);
  }
 
  virtual Model::BatchRebootClusterNodesOutcome BatchRebootClusterNodes(const Model::BatchRebootClusterNodesRequest& request) const;
 
  template <typename BatchRebootClusterNodesRequestT = Model::BatchRebootClusterNodesRequest>
  Model::BatchRebootClusterNodesOutcomeCallable BatchRebootClusterNodesCallable(const BatchRebootClusterNodesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::BatchRebootClusterNodes, request);
  }
 
  template <typename BatchRebootClusterNodesRequestT = Model::BatchRebootClusterNodesRequest>
  void BatchRebootClusterNodesAsync(const BatchRebootClusterNodesRequestT& request,
                                    const BatchRebootClusterNodesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::BatchRebootClusterNodes, request, handler, context);
  }
 
  virtual Model::BatchReplaceClusterNodesOutcome BatchReplaceClusterNodes(const Model::BatchReplaceClusterNodesRequest& request) const;
 
  template <typename BatchReplaceClusterNodesRequestT = Model::BatchReplaceClusterNodesRequest>
  Model::BatchReplaceClusterNodesOutcomeCallable BatchReplaceClusterNodesCallable(const BatchReplaceClusterNodesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::BatchReplaceClusterNodes, request);
  }
 
  template <typename BatchReplaceClusterNodesRequestT = Model::BatchReplaceClusterNodesRequest>
  void BatchReplaceClusterNodesAsync(const BatchReplaceClusterNodesRequestT& request,
                                     const BatchReplaceClusterNodesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::BatchReplaceClusterNodes, request, handler, context);
  }
 
  virtual Model::CreateActionOutcome CreateAction(const Model::CreateActionRequest& request) const;
 
  template <typename CreateActionRequestT = Model::CreateActionRequest>
  Model::CreateActionOutcomeCallable CreateActionCallable(const CreateActionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateAction, request);
  }
 
  template <typename CreateActionRequestT = Model::CreateActionRequest>
  void CreateActionAsync(const CreateActionRequestT& request, const CreateActionResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateAction, request, handler, context);
  }
 
  virtual Model::CreateAlgorithmOutcome CreateAlgorithm(const Model::CreateAlgorithmRequest& request) const;
 
  template <typename CreateAlgorithmRequestT = Model::CreateAlgorithmRequest>
  Model::CreateAlgorithmOutcomeCallable CreateAlgorithmCallable(const CreateAlgorithmRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateAlgorithm, request);
  }
 
  template <typename CreateAlgorithmRequestT = Model::CreateAlgorithmRequest>
  void CreateAlgorithmAsync(const CreateAlgorithmRequestT& request, const CreateAlgorithmResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateAlgorithm, request, handler, context);
  }
 
  virtual Model::CreateAppOutcome CreateApp(const Model::CreateAppRequest& request) const;
 
  template <typename CreateAppRequestT = Model::CreateAppRequest>
  Model::CreateAppOutcomeCallable CreateAppCallable(const CreateAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateApp, request);
  }
 
  template <typename CreateAppRequestT = Model::CreateAppRequest>
  void CreateAppAsync(const CreateAppRequestT& request, const CreateAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateApp, request, handler, context);
  }
 
  virtual Model::CreateAppImageConfigOutcome CreateAppImageConfig(const Model::CreateAppImageConfigRequest& request) const;
 
  template <typename CreateAppImageConfigRequestT = Model::CreateAppImageConfigRequest>
  Model::CreateAppImageConfigOutcomeCallable CreateAppImageConfigCallable(const CreateAppImageConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateAppImageConfig, request);
  }
 
  template <typename CreateAppImageConfigRequestT = Model::CreateAppImageConfigRequest>
  void CreateAppImageConfigAsync(const CreateAppImageConfigRequestT& request, const CreateAppImageConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateAppImageConfig, request, handler, context);
  }
 
  virtual Model::CreateArtifactOutcome CreateArtifact(const Model::CreateArtifactRequest& request) const;
 
  template <typename CreateArtifactRequestT = Model::CreateArtifactRequest>
  Model::CreateArtifactOutcomeCallable CreateArtifactCallable(const CreateArtifactRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateArtifact, request);
  }
 
  template <typename CreateArtifactRequestT = Model::CreateArtifactRequest>
  void CreateArtifactAsync(const CreateArtifactRequestT& request, const CreateArtifactResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateArtifact, request, handler, context);
  }
 
  virtual Model::CreateAutoMLJobOutcome CreateAutoMLJob(const Model::CreateAutoMLJobRequest& request) const;
 
  template <typename CreateAutoMLJobRequestT = Model::CreateAutoMLJobRequest>
  Model::CreateAutoMLJobOutcomeCallable CreateAutoMLJobCallable(const CreateAutoMLJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateAutoMLJob, request);
  }
 
  template <typename CreateAutoMLJobRequestT = Model::CreateAutoMLJobRequest>
  void CreateAutoMLJobAsync(const CreateAutoMLJobRequestT& request, const CreateAutoMLJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateAutoMLJob, request, handler, context);
  }
 
  virtual Model::CreateAutoMLJobV2Outcome CreateAutoMLJobV2(const Model::CreateAutoMLJobV2Request& request) const;
 
  template <typename CreateAutoMLJobV2RequestT = Model::CreateAutoMLJobV2Request>
  Model::CreateAutoMLJobV2OutcomeCallable CreateAutoMLJobV2Callable(const CreateAutoMLJobV2RequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateAutoMLJobV2, request);
  }
 
  template <typename CreateAutoMLJobV2RequestT = Model::CreateAutoMLJobV2Request>
  void CreateAutoMLJobV2Async(const CreateAutoMLJobV2RequestT& request, const CreateAutoMLJobV2ResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateAutoMLJobV2, request, handler, context);
  }
 
  virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request) const;
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateCluster, request);
  }
 
  template <typename CreateClusterRequestT = Model::CreateClusterRequest>
  void CreateClusterAsync(const CreateClusterRequestT& request, const CreateClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateCluster, request, handler, context);
  }
 
  virtual Model::CreateClusterSchedulerConfigOutcome CreateClusterSchedulerConfig(
      const Model::CreateClusterSchedulerConfigRequest& request) const;
 
  template <typename CreateClusterSchedulerConfigRequestT = Model::CreateClusterSchedulerConfigRequest>
  Model::CreateClusterSchedulerConfigOutcomeCallable CreateClusterSchedulerConfigCallable(
      const CreateClusterSchedulerConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateClusterSchedulerConfig, request);
  }
 
  template <typename CreateClusterSchedulerConfigRequestT = Model::CreateClusterSchedulerConfigRequest>
  void CreateClusterSchedulerConfigAsync(const CreateClusterSchedulerConfigRequestT& request,
                                         const CreateClusterSchedulerConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateClusterSchedulerConfig, request, handler, context);
  }
 
  virtual Model::CreateCodeRepositoryOutcome CreateCodeRepository(const Model::CreateCodeRepositoryRequest& request) const;
 
  template <typename CreateCodeRepositoryRequestT = Model::CreateCodeRepositoryRequest>
  Model::CreateCodeRepositoryOutcomeCallable CreateCodeRepositoryCallable(const CreateCodeRepositoryRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateCodeRepository, request);
  }
 
  template <typename CreateCodeRepositoryRequestT = Model::CreateCodeRepositoryRequest>
  void CreateCodeRepositoryAsync(const CreateCodeRepositoryRequestT& request, const CreateCodeRepositoryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateCodeRepository, request, handler, context);
  }
 
  virtual Model::CreateCompilationJobOutcome CreateCompilationJob(const Model::CreateCompilationJobRequest& request) const;
 
  template <typename CreateCompilationJobRequestT = Model::CreateCompilationJobRequest>
  Model::CreateCompilationJobOutcomeCallable CreateCompilationJobCallable(const CreateCompilationJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateCompilationJob, request);
  }
 
  template <typename CreateCompilationJobRequestT = Model::CreateCompilationJobRequest>
  void CreateCompilationJobAsync(const CreateCompilationJobRequestT& request, const CreateCompilationJobResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateCompilationJob, request, handler, context);
  }
 
  virtual Model::CreateComputeQuotaOutcome CreateComputeQuota(const Model::CreateComputeQuotaRequest& request) const;
 
  template <typename CreateComputeQuotaRequestT = Model::CreateComputeQuotaRequest>
  Model::CreateComputeQuotaOutcomeCallable CreateComputeQuotaCallable(const CreateComputeQuotaRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateComputeQuota, request);
  }
 
  template <typename CreateComputeQuotaRequestT = Model::CreateComputeQuotaRequest>
  void CreateComputeQuotaAsync(const CreateComputeQuotaRequestT& request, const CreateComputeQuotaResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateComputeQuota, request, handler, context);
  }
 
  virtual Model::CreateContextOutcome CreateContext(const Model::CreateContextRequest& request) const;
 
  template <typename CreateContextRequestT = Model::CreateContextRequest>
  Model::CreateContextOutcomeCallable CreateContextCallable(const CreateContextRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateContext, request);
  }
 
  template <typename CreateContextRequestT = Model::CreateContextRequest>
  void CreateContextAsync(const CreateContextRequestT& request, const CreateContextResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateContext, request, handler, context);
  }
 
  virtual Model::CreateDataQualityJobDefinitionOutcome CreateDataQualityJobDefinition(
      const Model::CreateDataQualityJobDefinitionRequest& request) const;
 
  template <typename CreateDataQualityJobDefinitionRequestT = Model::CreateDataQualityJobDefinitionRequest>
  Model::CreateDataQualityJobDefinitionOutcomeCallable CreateDataQualityJobDefinitionCallable(
      const CreateDataQualityJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateDataQualityJobDefinition, request);
  }
 
  template <typename CreateDataQualityJobDefinitionRequestT = Model::CreateDataQualityJobDefinitionRequest>
  void CreateDataQualityJobDefinitionAsync(const CreateDataQualityJobDefinitionRequestT& request,
                                           const CreateDataQualityJobDefinitionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateDataQualityJobDefinition, request, handler, context);
  }
 
  virtual Model::CreateDeviceFleetOutcome CreateDeviceFleet(const Model::CreateDeviceFleetRequest& request) const;
 
  template <typename CreateDeviceFleetRequestT = Model::CreateDeviceFleetRequest>
  Model::CreateDeviceFleetOutcomeCallable CreateDeviceFleetCallable(const CreateDeviceFleetRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateDeviceFleet, request);
  }
 
  template <typename CreateDeviceFleetRequestT = Model::CreateDeviceFleetRequest>
  void CreateDeviceFleetAsync(const CreateDeviceFleetRequestT& request, const CreateDeviceFleetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateDeviceFleet, request, handler, context);
  }
 
  virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateDomain, request);
  }
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateDomain, request, handler, context);
  }
 
  virtual Model::CreateEdgeDeploymentPlanOutcome CreateEdgeDeploymentPlan(const Model::CreateEdgeDeploymentPlanRequest& request) const;
 
  template <typename CreateEdgeDeploymentPlanRequestT = Model::CreateEdgeDeploymentPlanRequest>
  Model::CreateEdgeDeploymentPlanOutcomeCallable CreateEdgeDeploymentPlanCallable(const CreateEdgeDeploymentPlanRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateEdgeDeploymentPlan, request);
  }
 
  template <typename CreateEdgeDeploymentPlanRequestT = Model::CreateEdgeDeploymentPlanRequest>
  void CreateEdgeDeploymentPlanAsync(const CreateEdgeDeploymentPlanRequestT& request,
                                     const CreateEdgeDeploymentPlanResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateEdgeDeploymentPlan, request, handler, context);
  }
 
  virtual Model::CreateEdgeDeploymentStageOutcome CreateEdgeDeploymentStage(const Model::CreateEdgeDeploymentStageRequest& request) const;
 
  template <typename CreateEdgeDeploymentStageRequestT = Model::CreateEdgeDeploymentStageRequest>
  Model::CreateEdgeDeploymentStageOutcomeCallable CreateEdgeDeploymentStageCallable(
      const CreateEdgeDeploymentStageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateEdgeDeploymentStage, request);
  }
 
  template <typename CreateEdgeDeploymentStageRequestT = Model::CreateEdgeDeploymentStageRequest>
  void CreateEdgeDeploymentStageAsync(const CreateEdgeDeploymentStageRequestT& request,
                                      const CreateEdgeDeploymentStageResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateEdgeDeploymentStage, request, handler, context);
  }
 
  virtual Model::CreateEdgePackagingJobOutcome CreateEdgePackagingJob(const Model::CreateEdgePackagingJobRequest& request) const;
 
  template <typename CreateEdgePackagingJobRequestT = Model::CreateEdgePackagingJobRequest>
  Model::CreateEdgePackagingJobOutcomeCallable CreateEdgePackagingJobCallable(const CreateEdgePackagingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateEdgePackagingJob, request);
  }
 
  template <typename CreateEdgePackagingJobRequestT = Model::CreateEdgePackagingJobRequest>
  void CreateEdgePackagingJobAsync(const CreateEdgePackagingJobRequestT& request,
                                   const CreateEdgePackagingJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateEdgePackagingJob, request, handler, context);
  }
 
  virtual Model::CreateEndpointOutcome CreateEndpoint(const Model::CreateEndpointRequest& request) const;
 
  template <typename CreateEndpointRequestT = Model::CreateEndpointRequest>
  Model::CreateEndpointOutcomeCallable CreateEndpointCallable(const CreateEndpointRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateEndpoint, request);
  }
 
  template <typename CreateEndpointRequestT = Model::CreateEndpointRequest>
  void CreateEndpointAsync(const CreateEndpointRequestT& request, const CreateEndpointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateEndpoint, request, handler, context);
  }
 
  virtual Model::CreateEndpointConfigOutcome CreateEndpointConfig(const Model::CreateEndpointConfigRequest& request) const;
 
  template <typename CreateEndpointConfigRequestT = Model::CreateEndpointConfigRequest>
  Model::CreateEndpointConfigOutcomeCallable CreateEndpointConfigCallable(const CreateEndpointConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateEndpointConfig, request);
  }
 
  template <typename CreateEndpointConfigRequestT = Model::CreateEndpointConfigRequest>
  void CreateEndpointConfigAsync(const CreateEndpointConfigRequestT& request, const CreateEndpointConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateEndpointConfig, request, handler, context);
  }
 
  virtual Model::CreateExperimentOutcome CreateExperiment(const Model::CreateExperimentRequest& request) const;
 
  template <typename CreateExperimentRequestT = Model::CreateExperimentRequest>
  Model::CreateExperimentOutcomeCallable CreateExperimentCallable(const CreateExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateExperiment, request);
  }
 
  template <typename CreateExperimentRequestT = Model::CreateExperimentRequest>
  void CreateExperimentAsync(const CreateExperimentRequestT& request, const CreateExperimentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateExperiment, request, handler, context);
  }
 
  virtual Model::CreateFeatureGroupOutcome CreateFeatureGroup(const Model::CreateFeatureGroupRequest& request) const;
 
  template <typename CreateFeatureGroupRequestT = Model::CreateFeatureGroupRequest>
  Model::CreateFeatureGroupOutcomeCallable CreateFeatureGroupCallable(const CreateFeatureGroupRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateFeatureGroup, request);
  }
 
  template <typename CreateFeatureGroupRequestT = Model::CreateFeatureGroupRequest>
  void CreateFeatureGroupAsync(const CreateFeatureGroupRequestT& request, const CreateFeatureGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateFeatureGroup, request, handler, context);
  }
 
  virtual Model::CreateFlowDefinitionOutcome CreateFlowDefinition(const Model::CreateFlowDefinitionRequest& request) const;
 
  template <typename CreateFlowDefinitionRequestT = Model::CreateFlowDefinitionRequest>
  Model::CreateFlowDefinitionOutcomeCallable CreateFlowDefinitionCallable(const CreateFlowDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateFlowDefinition, request);
  }
 
  template <typename CreateFlowDefinitionRequestT = Model::CreateFlowDefinitionRequest>
  void CreateFlowDefinitionAsync(const CreateFlowDefinitionRequestT& request, const CreateFlowDefinitionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateFlowDefinition, request, handler, context);
  }
 
  virtual Model::CreateHubOutcome CreateHub(const Model::CreateHubRequest& request) const;
 
  template <typename CreateHubRequestT = Model::CreateHubRequest>
  Model::CreateHubOutcomeCallable CreateHubCallable(const CreateHubRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateHub, request);
  }
 
  template <typename CreateHubRequestT = Model::CreateHubRequest>
  void CreateHubAsync(const CreateHubRequestT& request, const CreateHubResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateHub, request, handler, context);
  }
 
  virtual Model::CreateHubContentPresignedUrlsOutcome CreateHubContentPresignedUrls(
      const Model::CreateHubContentPresignedUrlsRequest& request) const;
 
  template <typename CreateHubContentPresignedUrlsRequestT = Model::CreateHubContentPresignedUrlsRequest>
  Model::CreateHubContentPresignedUrlsOutcomeCallable CreateHubContentPresignedUrlsCallable(
      const CreateHubContentPresignedUrlsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateHubContentPresignedUrls, request);
  }
 
  template <typename CreateHubContentPresignedUrlsRequestT = Model::CreateHubContentPresignedUrlsRequest>
  void CreateHubContentPresignedUrlsAsync(const CreateHubContentPresignedUrlsRequestT& request,
                                          const CreateHubContentPresignedUrlsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateHubContentPresignedUrls, request, handler, context);
  }
 
  virtual Model::CreateHubContentReferenceOutcome CreateHubContentReference(const Model::CreateHubContentReferenceRequest& request) const;
 
  template <typename CreateHubContentReferenceRequestT = Model::CreateHubContentReferenceRequest>
  Model::CreateHubContentReferenceOutcomeCallable CreateHubContentReferenceCallable(
      const CreateHubContentReferenceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateHubContentReference, request);
  }
 
  template <typename CreateHubContentReferenceRequestT = Model::CreateHubContentReferenceRequest>
  void CreateHubContentReferenceAsync(const CreateHubContentReferenceRequestT& request,
                                      const CreateHubContentReferenceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateHubContentReference, request, handler, context);
  }
 
  virtual Model::CreateHumanTaskUiOutcome CreateHumanTaskUi(const Model::CreateHumanTaskUiRequest& request) const;
 
  template <typename CreateHumanTaskUiRequestT = Model::CreateHumanTaskUiRequest>
  Model::CreateHumanTaskUiOutcomeCallable CreateHumanTaskUiCallable(const CreateHumanTaskUiRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateHumanTaskUi, request);
  }
 
  template <typename CreateHumanTaskUiRequestT = Model::CreateHumanTaskUiRequest>
  void CreateHumanTaskUiAsync(const CreateHumanTaskUiRequestT& request, const CreateHumanTaskUiResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateHumanTaskUi, request, handler, context);
  }
 
  virtual Model::CreateHyperParameterTuningJobOutcome CreateHyperParameterTuningJob(
      const Model::CreateHyperParameterTuningJobRequest& request) const;
 
  template <typename CreateHyperParameterTuningJobRequestT = Model::CreateHyperParameterTuningJobRequest>
  Model::CreateHyperParameterTuningJobOutcomeCallable CreateHyperParameterTuningJobCallable(
      const CreateHyperParameterTuningJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateHyperParameterTuningJob, request);
  }
 
  template <typename CreateHyperParameterTuningJobRequestT = Model::CreateHyperParameterTuningJobRequest>
  void CreateHyperParameterTuningJobAsync(const CreateHyperParameterTuningJobRequestT& request,
                                          const CreateHyperParameterTuningJobResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateHyperParameterTuningJob, request, handler, context);
  }
 
  virtual Model::CreateImageOutcome CreateImage(const Model::CreateImageRequest& request) const;
 
  template <typename CreateImageRequestT = Model::CreateImageRequest>
  Model::CreateImageOutcomeCallable CreateImageCallable(const CreateImageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateImage, request);
  }
 
  template <typename CreateImageRequestT = Model::CreateImageRequest>
  void CreateImageAsync(const CreateImageRequestT& request, const CreateImageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateImage, request, handler, context);
  }
 
  virtual Model::CreateImageVersionOutcome CreateImageVersion(const Model::CreateImageVersionRequest& request) const;
 
  template <typename CreateImageVersionRequestT = Model::CreateImageVersionRequest>
  Model::CreateImageVersionOutcomeCallable CreateImageVersionCallable(const CreateImageVersionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateImageVersion, request);
  }
 
  template <typename CreateImageVersionRequestT = Model::CreateImageVersionRequest>
  void CreateImageVersionAsync(const CreateImageVersionRequestT& request, const CreateImageVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateImageVersion, request, handler, context);
  }
 
  virtual Model::CreateInferenceComponentOutcome CreateInferenceComponent(const Model::CreateInferenceComponentRequest& request) const;
 
  template <typename CreateInferenceComponentRequestT = Model::CreateInferenceComponentRequest>
  Model::CreateInferenceComponentOutcomeCallable CreateInferenceComponentCallable(const CreateInferenceComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateInferenceComponent, request);
  }
 
  template <typename CreateInferenceComponentRequestT = Model::CreateInferenceComponentRequest>
  void CreateInferenceComponentAsync(const CreateInferenceComponentRequestT& request,
                                     const CreateInferenceComponentResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateInferenceComponent, request, handler, context);
  }
 
  virtual Model::CreateInferenceExperimentOutcome CreateInferenceExperiment(const Model::CreateInferenceExperimentRequest& request) const;
 
  template <typename CreateInferenceExperimentRequestT = Model::CreateInferenceExperimentRequest>
  Model::CreateInferenceExperimentOutcomeCallable CreateInferenceExperimentCallable(
      const CreateInferenceExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateInferenceExperiment, request);
  }
 
  template <typename CreateInferenceExperimentRequestT = Model::CreateInferenceExperimentRequest>
  void CreateInferenceExperimentAsync(const CreateInferenceExperimentRequestT& request,
                                      const CreateInferenceExperimentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateInferenceExperiment, request, handler, context);
  }
 
  virtual Model::CreateInferenceRecommendationsJobOutcome CreateInferenceRecommendationsJob(
      const Model::CreateInferenceRecommendationsJobRequest& request) const;
 
  template <typename CreateInferenceRecommendationsJobRequestT = Model::CreateInferenceRecommendationsJobRequest>
  Model::CreateInferenceRecommendationsJobOutcomeCallable CreateInferenceRecommendationsJobCallable(
      const CreateInferenceRecommendationsJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateInferenceRecommendationsJob, request);
  }
 
  template <typename CreateInferenceRecommendationsJobRequestT = Model::CreateInferenceRecommendationsJobRequest>
  void CreateInferenceRecommendationsJobAsync(const CreateInferenceRecommendationsJobRequestT& request,
                                              const CreateInferenceRecommendationsJobResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateInferenceRecommendationsJob, request, handler, context);
  }
 
  virtual Model::CreateLabelingJobOutcome CreateLabelingJob(const Model::CreateLabelingJobRequest& request) const;
 
  template <typename CreateLabelingJobRequestT = Model::CreateLabelingJobRequest>
  Model::CreateLabelingJobOutcomeCallable CreateLabelingJobCallable(const CreateLabelingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateLabelingJob, request);
  }
 
  template <typename CreateLabelingJobRequestT = Model::CreateLabelingJobRequest>
  void CreateLabelingJobAsync(const CreateLabelingJobRequestT& request, const CreateLabelingJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateLabelingJob, request, handler, context);
  }
 
  virtual Model::CreateMlflowAppOutcome CreateMlflowApp(const Model::CreateMlflowAppRequest& request) const;
 
  template <typename CreateMlflowAppRequestT = Model::CreateMlflowAppRequest>
  Model::CreateMlflowAppOutcomeCallable CreateMlflowAppCallable(const CreateMlflowAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateMlflowApp, request);
  }
 
  template <typename CreateMlflowAppRequestT = Model::CreateMlflowAppRequest>
  void CreateMlflowAppAsync(const CreateMlflowAppRequestT& request, const CreateMlflowAppResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateMlflowApp, request, handler, context);
  }
 
  virtual Model::CreateMlflowTrackingServerOutcome CreateMlflowTrackingServer(
      const Model::CreateMlflowTrackingServerRequest& request) const;
 
  template <typename CreateMlflowTrackingServerRequestT = Model::CreateMlflowTrackingServerRequest>
  Model::CreateMlflowTrackingServerOutcomeCallable CreateMlflowTrackingServerCallable(
      const CreateMlflowTrackingServerRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateMlflowTrackingServer, request);
  }
 
  template <typename CreateMlflowTrackingServerRequestT = Model::CreateMlflowTrackingServerRequest>
  void CreateMlflowTrackingServerAsync(const CreateMlflowTrackingServerRequestT& request,
                                       const CreateMlflowTrackingServerResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateMlflowTrackingServer, request, handler, context);
  }
 
  virtual Model::CreateModelOutcome CreateModel(const Model::CreateModelRequest& request) const;
 
  template <typename CreateModelRequestT = Model::CreateModelRequest>
  Model::CreateModelOutcomeCallable CreateModelCallable(const CreateModelRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateModel, request);
  }
 
  template <typename CreateModelRequestT = Model::CreateModelRequest>
  void CreateModelAsync(const CreateModelRequestT& request, const CreateModelResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateModel, request, handler, context);
  }
 
  virtual Model::CreateModelBiasJobDefinitionOutcome CreateModelBiasJobDefinition(
      const Model::CreateModelBiasJobDefinitionRequest& request) const;
 
  template <typename CreateModelBiasJobDefinitionRequestT = Model::CreateModelBiasJobDefinitionRequest>
  Model::CreateModelBiasJobDefinitionOutcomeCallable CreateModelBiasJobDefinitionCallable(
      const CreateModelBiasJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateModelBiasJobDefinition, request);
  }
 
  template <typename CreateModelBiasJobDefinitionRequestT = Model::CreateModelBiasJobDefinitionRequest>
  void CreateModelBiasJobDefinitionAsync(const CreateModelBiasJobDefinitionRequestT& request,
                                         const CreateModelBiasJobDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateModelBiasJobDefinition, request, handler, context);
  }
 
  virtual Model::CreateModelCardOutcome CreateModelCard(const Model::CreateModelCardRequest& request) const;
 
  template <typename CreateModelCardRequestT = Model::CreateModelCardRequest>
  Model::CreateModelCardOutcomeCallable CreateModelCardCallable(const CreateModelCardRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateModelCard, request);
  }
 
  template <typename CreateModelCardRequestT = Model::CreateModelCardRequest>
  void CreateModelCardAsync(const CreateModelCardRequestT& request, const CreateModelCardResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateModelCard, request, handler, context);
  }
 
  virtual Model::CreateModelCardExportJobOutcome CreateModelCardExportJob(const Model::CreateModelCardExportJobRequest& request) const;
 
  template <typename CreateModelCardExportJobRequestT = Model::CreateModelCardExportJobRequest>
  Model::CreateModelCardExportJobOutcomeCallable CreateModelCardExportJobCallable(const CreateModelCardExportJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateModelCardExportJob, request);
  }
 
  template <typename CreateModelCardExportJobRequestT = Model::CreateModelCardExportJobRequest>
  void CreateModelCardExportJobAsync(const CreateModelCardExportJobRequestT& request,
                                     const CreateModelCardExportJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateModelCardExportJob, request, handler, context);
  }
 
  virtual Model::CreateModelExplainabilityJobDefinitionOutcome CreateModelExplainabilityJobDefinition(
      const Model::CreateModelExplainabilityJobDefinitionRequest& request) const;
 
  template <typename CreateModelExplainabilityJobDefinitionRequestT = Model::CreateModelExplainabilityJobDefinitionRequest>
  Model::CreateModelExplainabilityJobDefinitionOutcomeCallable CreateModelExplainabilityJobDefinitionCallable(
      const CreateModelExplainabilityJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateModelExplainabilityJobDefinition, request);
  }
 
  template <typename CreateModelExplainabilityJobDefinitionRequestT = Model::CreateModelExplainabilityJobDefinitionRequest>
  void CreateModelExplainabilityJobDefinitionAsync(const CreateModelExplainabilityJobDefinitionRequestT& request,
                                                   const CreateModelExplainabilityJobDefinitionResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateModelExplainabilityJobDefinition, request, handler, context);
  }
 
  virtual Model::CreateModelPackageOutcome CreateModelPackage(const Model::CreateModelPackageRequest& request = {}) const;
 
  template <typename CreateModelPackageRequestT = Model::CreateModelPackageRequest>
  Model::CreateModelPackageOutcomeCallable CreateModelPackageCallable(const CreateModelPackageRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::CreateModelPackage, request);
  }
 
  template <typename CreateModelPackageRequestT = Model::CreateModelPackageRequest>
  void CreateModelPackageAsync(const CreateModelPackageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const CreateModelPackageRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::CreateModelPackage, request, handler, context);
  }
 
  virtual Model::CreateModelPackageGroupOutcome CreateModelPackageGroup(const Model::CreateModelPackageGroupRequest& request) const;
 
  template <typename CreateModelPackageGroupRequestT = Model::CreateModelPackageGroupRequest>
  Model::CreateModelPackageGroupOutcomeCallable CreateModelPackageGroupCallable(const CreateModelPackageGroupRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateModelPackageGroup, request);
  }
 
  template <typename CreateModelPackageGroupRequestT = Model::CreateModelPackageGroupRequest>
  void CreateModelPackageGroupAsync(const CreateModelPackageGroupRequestT& request,
                                    const CreateModelPackageGroupResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateModelPackageGroup, request, handler, context);
  }
 
  virtual Model::CreateModelQualityJobDefinitionOutcome CreateModelQualityJobDefinition(
      const Model::CreateModelQualityJobDefinitionRequest& request) const;
 
  template <typename CreateModelQualityJobDefinitionRequestT = Model::CreateModelQualityJobDefinitionRequest>
  Model::CreateModelQualityJobDefinitionOutcomeCallable CreateModelQualityJobDefinitionCallable(
      const CreateModelQualityJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateModelQualityJobDefinition, request);
  }
 
  template <typename CreateModelQualityJobDefinitionRequestT = Model::CreateModelQualityJobDefinitionRequest>
  void CreateModelQualityJobDefinitionAsync(const CreateModelQualityJobDefinitionRequestT& request,
                                            const CreateModelQualityJobDefinitionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateModelQualityJobDefinition, request, handler, context);
  }
 
  virtual Model::CreateMonitoringScheduleOutcome CreateMonitoringSchedule(const Model::CreateMonitoringScheduleRequest& request) const;
 
  template <typename CreateMonitoringScheduleRequestT = Model::CreateMonitoringScheduleRequest>
  Model::CreateMonitoringScheduleOutcomeCallable CreateMonitoringScheduleCallable(const CreateMonitoringScheduleRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateMonitoringSchedule, request);
  }
 
  template <typename CreateMonitoringScheduleRequestT = Model::CreateMonitoringScheduleRequest>
  void CreateMonitoringScheduleAsync(const CreateMonitoringScheduleRequestT& request,
                                     const CreateMonitoringScheduleResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateMonitoringSchedule, request, handler, context);
  }
 
  virtual Model::CreateNotebookInstanceOutcome CreateNotebookInstance(const Model::CreateNotebookInstanceRequest& request) const;
 
  template <typename CreateNotebookInstanceRequestT = Model::CreateNotebookInstanceRequest>
  Model::CreateNotebookInstanceOutcomeCallable CreateNotebookInstanceCallable(const CreateNotebookInstanceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateNotebookInstance, request);
  }
 
  template <typename CreateNotebookInstanceRequestT = Model::CreateNotebookInstanceRequest>
  void CreateNotebookInstanceAsync(const CreateNotebookInstanceRequestT& request,
                                   const CreateNotebookInstanceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateNotebookInstance, request, handler, context);
  }
 
  virtual Model::CreateNotebookInstanceLifecycleConfigOutcome CreateNotebookInstanceLifecycleConfig(
      const Model::CreateNotebookInstanceLifecycleConfigRequest& request) const;
 
  template <typename CreateNotebookInstanceLifecycleConfigRequestT = Model::CreateNotebookInstanceLifecycleConfigRequest>
  Model::CreateNotebookInstanceLifecycleConfigOutcomeCallable CreateNotebookInstanceLifecycleConfigCallable(
      const CreateNotebookInstanceLifecycleConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateNotebookInstanceLifecycleConfig, request);
  }
 
  template <typename CreateNotebookInstanceLifecycleConfigRequestT = Model::CreateNotebookInstanceLifecycleConfigRequest>
  void CreateNotebookInstanceLifecycleConfigAsync(const CreateNotebookInstanceLifecycleConfigRequestT& request,
                                                  const CreateNotebookInstanceLifecycleConfigResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateNotebookInstanceLifecycleConfig, request, handler, context);
  }
 
  virtual Model::CreateOptimizationJobOutcome CreateOptimizationJob(const Model::CreateOptimizationJobRequest& request) const;
 
  template <typename CreateOptimizationJobRequestT = Model::CreateOptimizationJobRequest>
  Model::CreateOptimizationJobOutcomeCallable CreateOptimizationJobCallable(const CreateOptimizationJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateOptimizationJob, request);
  }
 
  template <typename CreateOptimizationJobRequestT = Model::CreateOptimizationJobRequest>
  void CreateOptimizationJobAsync(const CreateOptimizationJobRequestT& request, const CreateOptimizationJobResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateOptimizationJob, request, handler, context);
  }
 
  virtual Model::CreatePartnerAppOutcome CreatePartnerApp(const Model::CreatePartnerAppRequest& request) const;
 
  template <typename CreatePartnerAppRequestT = Model::CreatePartnerAppRequest>
  Model::CreatePartnerAppOutcomeCallable CreatePartnerAppCallable(const CreatePartnerAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreatePartnerApp, request);
  }
 
  template <typename CreatePartnerAppRequestT = Model::CreatePartnerAppRequest>
  void CreatePartnerAppAsync(const CreatePartnerAppRequestT& request, const CreatePartnerAppResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreatePartnerApp, request, handler, context);
  }
 
  virtual Model::CreatePartnerAppPresignedUrlOutcome CreatePartnerAppPresignedUrl(
      const Model::CreatePartnerAppPresignedUrlRequest& request) const;
 
  template <typename CreatePartnerAppPresignedUrlRequestT = Model::CreatePartnerAppPresignedUrlRequest>
  Model::CreatePartnerAppPresignedUrlOutcomeCallable CreatePartnerAppPresignedUrlCallable(
      const CreatePartnerAppPresignedUrlRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreatePartnerAppPresignedUrl, request);
  }
 
  template <typename CreatePartnerAppPresignedUrlRequestT = Model::CreatePartnerAppPresignedUrlRequest>
  void CreatePartnerAppPresignedUrlAsync(const CreatePartnerAppPresignedUrlRequestT& request,
                                         const CreatePartnerAppPresignedUrlResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreatePartnerAppPresignedUrl, request, handler, context);
  }
 
  virtual Model::CreatePipelineOutcome CreatePipeline(const Model::CreatePipelineRequest& request) const;
 
  template <typename CreatePipelineRequestT = Model::CreatePipelineRequest>
  Model::CreatePipelineOutcomeCallable CreatePipelineCallable(const CreatePipelineRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreatePipeline, request);
  }
 
  template <typename CreatePipelineRequestT = Model::CreatePipelineRequest>
  void CreatePipelineAsync(const CreatePipelineRequestT& request, const CreatePipelineResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreatePipeline, request, handler, context);
  }
 
  virtual Model::CreatePresignedDomainUrlOutcome CreatePresignedDomainUrl(const Model::CreatePresignedDomainUrlRequest& request) const;
 
  template <typename CreatePresignedDomainUrlRequestT = Model::CreatePresignedDomainUrlRequest>
  Model::CreatePresignedDomainUrlOutcomeCallable CreatePresignedDomainUrlCallable(const CreatePresignedDomainUrlRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreatePresignedDomainUrl, request);
  }
 
  template <typename CreatePresignedDomainUrlRequestT = Model::CreatePresignedDomainUrlRequest>
  void CreatePresignedDomainUrlAsync(const CreatePresignedDomainUrlRequestT& request,
                                     const CreatePresignedDomainUrlResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreatePresignedDomainUrl, request, handler, context);
  }
 
  virtual Model::CreatePresignedMlflowAppUrlOutcome CreatePresignedMlflowAppUrl(
      const Model::CreatePresignedMlflowAppUrlRequest& request) const;
 
  template <typename CreatePresignedMlflowAppUrlRequestT = Model::CreatePresignedMlflowAppUrlRequest>
  Model::CreatePresignedMlflowAppUrlOutcomeCallable CreatePresignedMlflowAppUrlCallable(
      const CreatePresignedMlflowAppUrlRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreatePresignedMlflowAppUrl, request);
  }
 
  template <typename CreatePresignedMlflowAppUrlRequestT = Model::CreatePresignedMlflowAppUrlRequest>
  void CreatePresignedMlflowAppUrlAsync(const CreatePresignedMlflowAppUrlRequestT& request,
                                        const CreatePresignedMlflowAppUrlResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreatePresignedMlflowAppUrl, request, handler, context);
  }
 
  virtual Model::CreatePresignedMlflowTrackingServerUrlOutcome CreatePresignedMlflowTrackingServerUrl(
      const Model::CreatePresignedMlflowTrackingServerUrlRequest& request) const;
 
  template <typename CreatePresignedMlflowTrackingServerUrlRequestT = Model::CreatePresignedMlflowTrackingServerUrlRequest>
  Model::CreatePresignedMlflowTrackingServerUrlOutcomeCallable CreatePresignedMlflowTrackingServerUrlCallable(
      const CreatePresignedMlflowTrackingServerUrlRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreatePresignedMlflowTrackingServerUrl, request);
  }
 
  template <typename CreatePresignedMlflowTrackingServerUrlRequestT = Model::CreatePresignedMlflowTrackingServerUrlRequest>
  void CreatePresignedMlflowTrackingServerUrlAsync(const CreatePresignedMlflowTrackingServerUrlRequestT& request,
                                                   const CreatePresignedMlflowTrackingServerUrlResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreatePresignedMlflowTrackingServerUrl, request, handler, context);
  }
 
  virtual Model::CreatePresignedNotebookInstanceUrlOutcome CreatePresignedNotebookInstanceUrl(
      const Model::CreatePresignedNotebookInstanceUrlRequest& request) const;
 
  template <typename CreatePresignedNotebookInstanceUrlRequestT = Model::CreatePresignedNotebookInstanceUrlRequest>
  Model::CreatePresignedNotebookInstanceUrlOutcomeCallable CreatePresignedNotebookInstanceUrlCallable(
      const CreatePresignedNotebookInstanceUrlRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreatePresignedNotebookInstanceUrl, request);
  }
 
  template <typename CreatePresignedNotebookInstanceUrlRequestT = Model::CreatePresignedNotebookInstanceUrlRequest>
  void CreatePresignedNotebookInstanceUrlAsync(const CreatePresignedNotebookInstanceUrlRequestT& request,
                                               const CreatePresignedNotebookInstanceUrlResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreatePresignedNotebookInstanceUrl, request, handler, context);
  }
 
  virtual Model::CreateProcessingJobOutcome CreateProcessingJob(const Model::CreateProcessingJobRequest& request) const;
 
  template <typename CreateProcessingJobRequestT = Model::CreateProcessingJobRequest>
  Model::CreateProcessingJobOutcomeCallable CreateProcessingJobCallable(const CreateProcessingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateProcessingJob, request);
  }
 
  template <typename CreateProcessingJobRequestT = Model::CreateProcessingJobRequest>
  void CreateProcessingJobAsync(const CreateProcessingJobRequestT& request, const CreateProcessingJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateProcessingJob, request, handler, context);
  }
 
  virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const;
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateProject, request);
  }
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateProject, request, handler, context);
  }
 
  virtual Model::CreateSpaceOutcome CreateSpace(const Model::CreateSpaceRequest& request) const;
 
  template <typename CreateSpaceRequestT = Model::CreateSpaceRequest>
  Model::CreateSpaceOutcomeCallable CreateSpaceCallable(const CreateSpaceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateSpace, request);
  }
 
  template <typename CreateSpaceRequestT = Model::CreateSpaceRequest>
  void CreateSpaceAsync(const CreateSpaceRequestT& request, const CreateSpaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateSpace, request, handler, context);
  }
 
  virtual Model::CreateStudioLifecycleConfigOutcome CreateStudioLifecycleConfig(
      const Model::CreateStudioLifecycleConfigRequest& request) const;
 
  template <typename CreateStudioLifecycleConfigRequestT = Model::CreateStudioLifecycleConfigRequest>
  Model::CreateStudioLifecycleConfigOutcomeCallable CreateStudioLifecycleConfigCallable(
      const CreateStudioLifecycleConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateStudioLifecycleConfig, request);
  }
 
  template <typename CreateStudioLifecycleConfigRequestT = Model::CreateStudioLifecycleConfigRequest>
  void CreateStudioLifecycleConfigAsync(const CreateStudioLifecycleConfigRequestT& request,
                                        const CreateStudioLifecycleConfigResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateStudioLifecycleConfig, request, handler, context);
  }
 
  virtual Model::CreateTrainingJobOutcome CreateTrainingJob(const Model::CreateTrainingJobRequest& request) const;
 
  template <typename CreateTrainingJobRequestT = Model::CreateTrainingJobRequest>
  Model::CreateTrainingJobOutcomeCallable CreateTrainingJobCallable(const CreateTrainingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateTrainingJob, request);
  }
 
  template <typename CreateTrainingJobRequestT = Model::CreateTrainingJobRequest>
  void CreateTrainingJobAsync(const CreateTrainingJobRequestT& request, const CreateTrainingJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateTrainingJob, request, handler, context);
  }
 
  virtual Model::CreateTrainingPlanOutcome CreateTrainingPlan(const Model::CreateTrainingPlanRequest& request) const;
 
  template <typename CreateTrainingPlanRequestT = Model::CreateTrainingPlanRequest>
  Model::CreateTrainingPlanOutcomeCallable CreateTrainingPlanCallable(const CreateTrainingPlanRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateTrainingPlan, request);
  }
 
  template <typename CreateTrainingPlanRequestT = Model::CreateTrainingPlanRequest>
  void CreateTrainingPlanAsync(const CreateTrainingPlanRequestT& request, const CreateTrainingPlanResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateTrainingPlan, request, handler, context);
  }
 
  virtual Model::CreateTransformJobOutcome CreateTransformJob(const Model::CreateTransformJobRequest& request) const;
 
  template <typename CreateTransformJobRequestT = Model::CreateTransformJobRequest>
  Model::CreateTransformJobOutcomeCallable CreateTransformJobCallable(const CreateTransformJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateTransformJob, request);
  }
 
  template <typename CreateTransformJobRequestT = Model::CreateTransformJobRequest>
  void CreateTransformJobAsync(const CreateTransformJobRequestT& request, const CreateTransformJobResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateTransformJob, request, handler, context);
  }
 
  virtual Model::CreateTrialOutcome CreateTrial(const Model::CreateTrialRequest& request) const;
 
  template <typename CreateTrialRequestT = Model::CreateTrialRequest>
  Model::CreateTrialOutcomeCallable CreateTrialCallable(const CreateTrialRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateTrial, request);
  }
 
  template <typename CreateTrialRequestT = Model::CreateTrialRequest>
  void CreateTrialAsync(const CreateTrialRequestT& request, const CreateTrialResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateTrial, request, handler, context);
  }
 
  virtual Model::CreateTrialComponentOutcome CreateTrialComponent(const Model::CreateTrialComponentRequest& request) const;
 
  template <typename CreateTrialComponentRequestT = Model::CreateTrialComponentRequest>
  Model::CreateTrialComponentOutcomeCallable CreateTrialComponentCallable(const CreateTrialComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateTrialComponent, request);
  }
 
  template <typename CreateTrialComponentRequestT = Model::CreateTrialComponentRequest>
  void CreateTrialComponentAsync(const CreateTrialComponentRequestT& request, const CreateTrialComponentResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateTrialComponent, request, handler, context);
  }
 
  virtual Model::CreateUserProfileOutcome CreateUserProfile(const Model::CreateUserProfileRequest& request) const;
 
  template <typename CreateUserProfileRequestT = Model::CreateUserProfileRequest>
  Model::CreateUserProfileOutcomeCallable CreateUserProfileCallable(const CreateUserProfileRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateUserProfile, request);
  }
 
  template <typename CreateUserProfileRequestT = Model::CreateUserProfileRequest>
  void CreateUserProfileAsync(const CreateUserProfileRequestT& request, const CreateUserProfileResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateUserProfile, request, handler, context);
  }
 
  virtual Model::CreateWorkforceOutcome CreateWorkforce(const Model::CreateWorkforceRequest& request) const;
 
  template <typename CreateWorkforceRequestT = Model::CreateWorkforceRequest>
  Model::CreateWorkforceOutcomeCallable CreateWorkforceCallable(const CreateWorkforceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateWorkforce, request);
  }
 
  template <typename CreateWorkforceRequestT = Model::CreateWorkforceRequest>
  void CreateWorkforceAsync(const CreateWorkforceRequestT& request, const CreateWorkforceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateWorkforce, request, handler, context);
  }
 
  virtual Model::CreateWorkteamOutcome CreateWorkteam(const Model::CreateWorkteamRequest& request) const;
 
  template <typename CreateWorkteamRequestT = Model::CreateWorkteamRequest>
  Model::CreateWorkteamOutcomeCallable CreateWorkteamCallable(const CreateWorkteamRequestT& request) const {
    return SubmitCallable(&SageMakerClient::CreateWorkteam, request);
  }
 
  template <typename CreateWorkteamRequestT = Model::CreateWorkteamRequest>
  void CreateWorkteamAsync(const CreateWorkteamRequestT& request, const CreateWorkteamResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::CreateWorkteam, request, handler, context);
  }
 
  virtual Model::DeleteActionOutcome DeleteAction(const Model::DeleteActionRequest& request) const;
 
  template <typename DeleteActionRequestT = Model::DeleteActionRequest>
  Model::DeleteActionOutcomeCallable DeleteActionCallable(const DeleteActionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteAction, request);
  }
 
  template <typename DeleteActionRequestT = Model::DeleteActionRequest>
  void DeleteActionAsync(const DeleteActionRequestT& request, const DeleteActionResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteAction, request, handler, context);
  }
 
  virtual Model::DeleteAlgorithmOutcome DeleteAlgorithm(const Model::DeleteAlgorithmRequest& request) const;
 
  template <typename DeleteAlgorithmRequestT = Model::DeleteAlgorithmRequest>
  Model::DeleteAlgorithmOutcomeCallable DeleteAlgorithmCallable(const DeleteAlgorithmRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteAlgorithm, request);
  }
 
  template <typename DeleteAlgorithmRequestT = Model::DeleteAlgorithmRequest>
  void DeleteAlgorithmAsync(const DeleteAlgorithmRequestT& request, const DeleteAlgorithmResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteAlgorithm, request, handler, context);
  }
 
  virtual Model::DeleteAppOutcome DeleteApp(const Model::DeleteAppRequest& request) const;
 
  template <typename DeleteAppRequestT = Model::DeleteAppRequest>
  Model::DeleteAppOutcomeCallable DeleteAppCallable(const DeleteAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteApp, request);
  }
 
  template <typename DeleteAppRequestT = Model::DeleteAppRequest>
  void DeleteAppAsync(const DeleteAppRequestT& request, const DeleteAppResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteApp, request, handler, context);
  }
 
  virtual Model::DeleteAppImageConfigOutcome DeleteAppImageConfig(const Model::DeleteAppImageConfigRequest& request) const;
 
  template <typename DeleteAppImageConfigRequestT = Model::DeleteAppImageConfigRequest>
  Model::DeleteAppImageConfigOutcomeCallable DeleteAppImageConfigCallable(const DeleteAppImageConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteAppImageConfig, request);
  }
 
  template <typename DeleteAppImageConfigRequestT = Model::DeleteAppImageConfigRequest>
  void DeleteAppImageConfigAsync(const DeleteAppImageConfigRequestT& request, const DeleteAppImageConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteAppImageConfig, request, handler, context);
  }
 
  virtual Model::DeleteArtifactOutcome DeleteArtifact(const Model::DeleteArtifactRequest& request = {}) const;
 
  template <typename DeleteArtifactRequestT = Model::DeleteArtifactRequest>
  Model::DeleteArtifactOutcomeCallable DeleteArtifactCallable(const DeleteArtifactRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::DeleteArtifact, request);
  }
 
  template <typename DeleteArtifactRequestT = Model::DeleteArtifactRequest>
  void DeleteArtifactAsync(const DeleteArtifactResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DeleteArtifactRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::DeleteArtifact, request, handler, context);
  }
 
  virtual Model::DeleteAssociationOutcome DeleteAssociation(const Model::DeleteAssociationRequest& request) const;
 
  template <typename DeleteAssociationRequestT = Model::DeleteAssociationRequest>
  Model::DeleteAssociationOutcomeCallable DeleteAssociationCallable(const DeleteAssociationRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteAssociation, request);
  }
 
  template <typename DeleteAssociationRequestT = Model::DeleteAssociationRequest>
  void DeleteAssociationAsync(const DeleteAssociationRequestT& request, const DeleteAssociationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteAssociation, request, handler, context);
  }
 
  virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
 
  template <typename DeleteClusterRequestT = Model::DeleteClusterRequest>
  Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteCluster, request);
  }
 
  template <typename DeleteClusterRequestT = Model::DeleteClusterRequest>
  void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteCluster, request, handler, context);
  }
 
  virtual Model::DeleteClusterSchedulerConfigOutcome DeleteClusterSchedulerConfig(
      const Model::DeleteClusterSchedulerConfigRequest& request) const;
 
  template <typename DeleteClusterSchedulerConfigRequestT = Model::DeleteClusterSchedulerConfigRequest>
  Model::DeleteClusterSchedulerConfigOutcomeCallable DeleteClusterSchedulerConfigCallable(
      const DeleteClusterSchedulerConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteClusterSchedulerConfig, request);
  }
 
  template <typename DeleteClusterSchedulerConfigRequestT = Model::DeleteClusterSchedulerConfigRequest>
  void DeleteClusterSchedulerConfigAsync(const DeleteClusterSchedulerConfigRequestT& request,
                                         const DeleteClusterSchedulerConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteClusterSchedulerConfig, request, handler, context);
  }
 
  virtual Model::DeleteCodeRepositoryOutcome DeleteCodeRepository(const Model::DeleteCodeRepositoryRequest& request) const;
 
  template <typename DeleteCodeRepositoryRequestT = Model::DeleteCodeRepositoryRequest>
  Model::DeleteCodeRepositoryOutcomeCallable DeleteCodeRepositoryCallable(const DeleteCodeRepositoryRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteCodeRepository, request);
  }
 
  template <typename DeleteCodeRepositoryRequestT = Model::DeleteCodeRepositoryRequest>
  void DeleteCodeRepositoryAsync(const DeleteCodeRepositoryRequestT& request, const DeleteCodeRepositoryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteCodeRepository, request, handler, context);
  }
 
  virtual Model::DeleteCompilationJobOutcome DeleteCompilationJob(const Model::DeleteCompilationJobRequest& request) const;
 
  template <typename DeleteCompilationJobRequestT = Model::DeleteCompilationJobRequest>
  Model::DeleteCompilationJobOutcomeCallable DeleteCompilationJobCallable(const DeleteCompilationJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteCompilationJob, request);
  }
 
  template <typename DeleteCompilationJobRequestT = Model::DeleteCompilationJobRequest>
  void DeleteCompilationJobAsync(const DeleteCompilationJobRequestT& request, const DeleteCompilationJobResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteCompilationJob, request, handler, context);
  }
 
  virtual Model::DeleteComputeQuotaOutcome DeleteComputeQuota(const Model::DeleteComputeQuotaRequest& request) const;
 
  template <typename DeleteComputeQuotaRequestT = Model::DeleteComputeQuotaRequest>
  Model::DeleteComputeQuotaOutcomeCallable DeleteComputeQuotaCallable(const DeleteComputeQuotaRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteComputeQuota, request);
  }
 
  template <typename DeleteComputeQuotaRequestT = Model::DeleteComputeQuotaRequest>
  void DeleteComputeQuotaAsync(const DeleteComputeQuotaRequestT& request, const DeleteComputeQuotaResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteComputeQuota, request, handler, context);
  }
 
  virtual Model::DeleteContextOutcome DeleteContext(const Model::DeleteContextRequest& request) const;
 
  template <typename DeleteContextRequestT = Model::DeleteContextRequest>
  Model::DeleteContextOutcomeCallable DeleteContextCallable(const DeleteContextRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteContext, request);
  }
 
  template <typename DeleteContextRequestT = Model::DeleteContextRequest>
  void DeleteContextAsync(const DeleteContextRequestT& request, const DeleteContextResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteContext, request, handler, context);
  }
 
  virtual Model::DeleteDataQualityJobDefinitionOutcome DeleteDataQualityJobDefinition(
      const Model::DeleteDataQualityJobDefinitionRequest& request) const;
 
  template <typename DeleteDataQualityJobDefinitionRequestT = Model::DeleteDataQualityJobDefinitionRequest>
  Model::DeleteDataQualityJobDefinitionOutcomeCallable DeleteDataQualityJobDefinitionCallable(
      const DeleteDataQualityJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteDataQualityJobDefinition, request);
  }
 
  template <typename DeleteDataQualityJobDefinitionRequestT = Model::DeleteDataQualityJobDefinitionRequest>
  void DeleteDataQualityJobDefinitionAsync(const DeleteDataQualityJobDefinitionRequestT& request,
                                           const DeleteDataQualityJobDefinitionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteDataQualityJobDefinition, request, handler, context);
  }
 
  virtual Model::DeleteDeviceFleetOutcome DeleteDeviceFleet(const Model::DeleteDeviceFleetRequest& request) const;
 
  template <typename DeleteDeviceFleetRequestT = Model::DeleteDeviceFleetRequest>
  Model::DeleteDeviceFleetOutcomeCallable DeleteDeviceFleetCallable(const DeleteDeviceFleetRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteDeviceFleet, request);
  }
 
  template <typename DeleteDeviceFleetRequestT = Model::DeleteDeviceFleetRequest>
  void DeleteDeviceFleetAsync(const DeleteDeviceFleetRequestT& request, const DeleteDeviceFleetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteDeviceFleet, request, handler, context);
  }
 
  virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteDomain, request);
  }
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteDomain, request, handler, context);
  }
 
  virtual Model::DeleteEdgeDeploymentPlanOutcome DeleteEdgeDeploymentPlan(const Model::DeleteEdgeDeploymentPlanRequest& request) const;
 
  template <typename DeleteEdgeDeploymentPlanRequestT = Model::DeleteEdgeDeploymentPlanRequest>
  Model::DeleteEdgeDeploymentPlanOutcomeCallable DeleteEdgeDeploymentPlanCallable(const DeleteEdgeDeploymentPlanRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteEdgeDeploymentPlan, request);
  }
 
  template <typename DeleteEdgeDeploymentPlanRequestT = Model::DeleteEdgeDeploymentPlanRequest>
  void DeleteEdgeDeploymentPlanAsync(const DeleteEdgeDeploymentPlanRequestT& request,
                                     const DeleteEdgeDeploymentPlanResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteEdgeDeploymentPlan, request, handler, context);
  }
 
  virtual Model::DeleteEdgeDeploymentStageOutcome DeleteEdgeDeploymentStage(const Model::DeleteEdgeDeploymentStageRequest& request) const;
 
  template <typename DeleteEdgeDeploymentStageRequestT = Model::DeleteEdgeDeploymentStageRequest>
  Model::DeleteEdgeDeploymentStageOutcomeCallable DeleteEdgeDeploymentStageCallable(
      const DeleteEdgeDeploymentStageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteEdgeDeploymentStage, request);
  }
 
  template <typename DeleteEdgeDeploymentStageRequestT = Model::DeleteEdgeDeploymentStageRequest>
  void DeleteEdgeDeploymentStageAsync(const DeleteEdgeDeploymentStageRequestT& request,
                                      const DeleteEdgeDeploymentStageResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteEdgeDeploymentStage, request, handler, context);
  }
 
  virtual Model::DeleteEndpointOutcome DeleteEndpoint(const Model::DeleteEndpointRequest& request) const;
 
  template <typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
  Model::DeleteEndpointOutcomeCallable DeleteEndpointCallable(const DeleteEndpointRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteEndpoint, request);
  }
 
  template <typename DeleteEndpointRequestT = Model::DeleteEndpointRequest>
  void DeleteEndpointAsync(const DeleteEndpointRequestT& request, const DeleteEndpointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteEndpointConfigOutcome DeleteEndpointConfig(const Model::DeleteEndpointConfigRequest& request) const;
 
  template <typename DeleteEndpointConfigRequestT = Model::DeleteEndpointConfigRequest>
  Model::DeleteEndpointConfigOutcomeCallable DeleteEndpointConfigCallable(const DeleteEndpointConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteEndpointConfig, request);
  }
 
  template <typename DeleteEndpointConfigRequestT = Model::DeleteEndpointConfigRequest>
  void DeleteEndpointConfigAsync(const DeleteEndpointConfigRequestT& request, const DeleteEndpointConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteEndpointConfig, request, handler, context);
  }
 
  virtual Model::DeleteExperimentOutcome DeleteExperiment(const Model::DeleteExperimentRequest& request) const;
 
  template <typename DeleteExperimentRequestT = Model::DeleteExperimentRequest>
  Model::DeleteExperimentOutcomeCallable DeleteExperimentCallable(const DeleteExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteExperiment, request);
  }
 
  template <typename DeleteExperimentRequestT = Model::DeleteExperimentRequest>
  void DeleteExperimentAsync(const DeleteExperimentRequestT& request, const DeleteExperimentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteExperiment, request, handler, context);
  }
 
  virtual Model::DeleteFeatureGroupOutcome DeleteFeatureGroup(const Model::DeleteFeatureGroupRequest& request) const;
 
  template <typename DeleteFeatureGroupRequestT = Model::DeleteFeatureGroupRequest>
  Model::DeleteFeatureGroupOutcomeCallable DeleteFeatureGroupCallable(const DeleteFeatureGroupRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteFeatureGroup, request);
  }
 
  template <typename DeleteFeatureGroupRequestT = Model::DeleteFeatureGroupRequest>
  void DeleteFeatureGroupAsync(const DeleteFeatureGroupRequestT& request, const DeleteFeatureGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteFeatureGroup, request, handler, context);
  }
 
  virtual Model::DeleteFlowDefinitionOutcome DeleteFlowDefinition(const Model::DeleteFlowDefinitionRequest& request) const;
 
  template <typename DeleteFlowDefinitionRequestT = Model::DeleteFlowDefinitionRequest>
  Model::DeleteFlowDefinitionOutcomeCallable DeleteFlowDefinitionCallable(const DeleteFlowDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteFlowDefinition, request);
  }
 
  template <typename DeleteFlowDefinitionRequestT = Model::DeleteFlowDefinitionRequest>
  void DeleteFlowDefinitionAsync(const DeleteFlowDefinitionRequestT& request, const DeleteFlowDefinitionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteFlowDefinition, request, handler, context);
  }
 
  virtual Model::DeleteHubOutcome DeleteHub(const Model::DeleteHubRequest& request) const;
 
  template <typename DeleteHubRequestT = Model::DeleteHubRequest>
  Model::DeleteHubOutcomeCallable DeleteHubCallable(const DeleteHubRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteHub, request);
  }
 
  template <typename DeleteHubRequestT = Model::DeleteHubRequest>
  void DeleteHubAsync(const DeleteHubRequestT& request, const DeleteHubResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteHub, request, handler, context);
  }
 
  virtual Model::DeleteHubContentOutcome DeleteHubContent(const Model::DeleteHubContentRequest& request) const;
 
  template <typename DeleteHubContentRequestT = Model::DeleteHubContentRequest>
  Model::DeleteHubContentOutcomeCallable DeleteHubContentCallable(const DeleteHubContentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteHubContent, request);
  }
 
  template <typename DeleteHubContentRequestT = Model::DeleteHubContentRequest>
  void DeleteHubContentAsync(const DeleteHubContentRequestT& request, const DeleteHubContentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteHubContent, request, handler, context);
  }
 
  virtual Model::DeleteHubContentReferenceOutcome DeleteHubContentReference(const Model::DeleteHubContentReferenceRequest& request) const;
 
  template <typename DeleteHubContentReferenceRequestT = Model::DeleteHubContentReferenceRequest>
  Model::DeleteHubContentReferenceOutcomeCallable DeleteHubContentReferenceCallable(
      const DeleteHubContentReferenceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteHubContentReference, request);
  }
 
  template <typename DeleteHubContentReferenceRequestT = Model::DeleteHubContentReferenceRequest>
  void DeleteHubContentReferenceAsync(const DeleteHubContentReferenceRequestT& request,
                                      const DeleteHubContentReferenceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteHubContentReference, request, handler, context);
  }
 
  virtual Model::DeleteHumanTaskUiOutcome DeleteHumanTaskUi(const Model::DeleteHumanTaskUiRequest& request) const;
 
  template <typename DeleteHumanTaskUiRequestT = Model::DeleteHumanTaskUiRequest>
  Model::DeleteHumanTaskUiOutcomeCallable DeleteHumanTaskUiCallable(const DeleteHumanTaskUiRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteHumanTaskUi, request);
  }
 
  template <typename DeleteHumanTaskUiRequestT = Model::DeleteHumanTaskUiRequest>
  void DeleteHumanTaskUiAsync(const DeleteHumanTaskUiRequestT& request, const DeleteHumanTaskUiResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteHumanTaskUi, request, handler, context);
  }
 
  virtual Model::DeleteHyperParameterTuningJobOutcome DeleteHyperParameterTuningJob(
      const Model::DeleteHyperParameterTuningJobRequest& request) const;
 
  template <typename DeleteHyperParameterTuningJobRequestT = Model::DeleteHyperParameterTuningJobRequest>
  Model::DeleteHyperParameterTuningJobOutcomeCallable DeleteHyperParameterTuningJobCallable(
      const DeleteHyperParameterTuningJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteHyperParameterTuningJob, request);
  }
 
  template <typename DeleteHyperParameterTuningJobRequestT = Model::DeleteHyperParameterTuningJobRequest>
  void DeleteHyperParameterTuningJobAsync(const DeleteHyperParameterTuningJobRequestT& request,
                                          const DeleteHyperParameterTuningJobResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteHyperParameterTuningJob, request, handler, context);
  }
 
  virtual Model::DeleteImageOutcome DeleteImage(const Model::DeleteImageRequest& request) const;
 
  template <typename DeleteImageRequestT = Model::DeleteImageRequest>
  Model::DeleteImageOutcomeCallable DeleteImageCallable(const DeleteImageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteImage, request);
  }
 
  template <typename DeleteImageRequestT = Model::DeleteImageRequest>
  void DeleteImageAsync(const DeleteImageRequestT& request, const DeleteImageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteImage, request, handler, context);
  }
 
  virtual Model::DeleteImageVersionOutcome DeleteImageVersion(const Model::DeleteImageVersionRequest& request) const;
 
  template <typename DeleteImageVersionRequestT = Model::DeleteImageVersionRequest>
  Model::DeleteImageVersionOutcomeCallable DeleteImageVersionCallable(const DeleteImageVersionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteImageVersion, request);
  }
 
  template <typename DeleteImageVersionRequestT = Model::DeleteImageVersionRequest>
  void DeleteImageVersionAsync(const DeleteImageVersionRequestT& request, const DeleteImageVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteImageVersion, request, handler, context);
  }
 
  virtual Model::DeleteInferenceComponentOutcome DeleteInferenceComponent(const Model::DeleteInferenceComponentRequest& request) const;
 
  template <typename DeleteInferenceComponentRequestT = Model::DeleteInferenceComponentRequest>
  Model::DeleteInferenceComponentOutcomeCallable DeleteInferenceComponentCallable(const DeleteInferenceComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteInferenceComponent, request);
  }
 
  template <typename DeleteInferenceComponentRequestT = Model::DeleteInferenceComponentRequest>
  void DeleteInferenceComponentAsync(const DeleteInferenceComponentRequestT& request,
                                     const DeleteInferenceComponentResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteInferenceComponent, request, handler, context);
  }
 
  virtual Model::DeleteInferenceExperimentOutcome DeleteInferenceExperiment(const Model::DeleteInferenceExperimentRequest& request) const;
 
  template <typename DeleteInferenceExperimentRequestT = Model::DeleteInferenceExperimentRequest>
  Model::DeleteInferenceExperimentOutcomeCallable DeleteInferenceExperimentCallable(
      const DeleteInferenceExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteInferenceExperiment, request);
  }
 
  template <typename DeleteInferenceExperimentRequestT = Model::DeleteInferenceExperimentRequest>
  void DeleteInferenceExperimentAsync(const DeleteInferenceExperimentRequestT& request,
                                      const DeleteInferenceExperimentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteInferenceExperiment, request, handler, context);
  }
 
  virtual Model::DeleteMlflowAppOutcome DeleteMlflowApp(const Model::DeleteMlflowAppRequest& request) const;
 
  template <typename DeleteMlflowAppRequestT = Model::DeleteMlflowAppRequest>
  Model::DeleteMlflowAppOutcomeCallable DeleteMlflowAppCallable(const DeleteMlflowAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteMlflowApp, request);
  }
 
  template <typename DeleteMlflowAppRequestT = Model::DeleteMlflowAppRequest>
  void DeleteMlflowAppAsync(const DeleteMlflowAppRequestT& request, const DeleteMlflowAppResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteMlflowApp, request, handler, context);
  }
 
  virtual Model::DeleteMlflowTrackingServerOutcome DeleteMlflowTrackingServer(
      const Model::DeleteMlflowTrackingServerRequest& request) const;
 
  template <typename DeleteMlflowTrackingServerRequestT = Model::DeleteMlflowTrackingServerRequest>
  Model::DeleteMlflowTrackingServerOutcomeCallable DeleteMlflowTrackingServerCallable(
      const DeleteMlflowTrackingServerRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteMlflowTrackingServer, request);
  }
 
  template <typename DeleteMlflowTrackingServerRequestT = Model::DeleteMlflowTrackingServerRequest>
  void DeleteMlflowTrackingServerAsync(const DeleteMlflowTrackingServerRequestT& request,
                                       const DeleteMlflowTrackingServerResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteMlflowTrackingServer, request, handler, context);
  }
 
  virtual Model::DeleteModelOutcome DeleteModel(const Model::DeleteModelRequest& request) const;
 
  template <typename DeleteModelRequestT = Model::DeleteModelRequest>
  Model::DeleteModelOutcomeCallable DeleteModelCallable(const DeleteModelRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteModel, request);
  }
 
  template <typename DeleteModelRequestT = Model::DeleteModelRequest>
  void DeleteModelAsync(const DeleteModelRequestT& request, const DeleteModelResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteModel, request, handler, context);
  }
 
  virtual Model::DeleteModelBiasJobDefinitionOutcome DeleteModelBiasJobDefinition(
      const Model::DeleteModelBiasJobDefinitionRequest& request) const;
 
  template <typename DeleteModelBiasJobDefinitionRequestT = Model::DeleteModelBiasJobDefinitionRequest>
  Model::DeleteModelBiasJobDefinitionOutcomeCallable DeleteModelBiasJobDefinitionCallable(
      const DeleteModelBiasJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteModelBiasJobDefinition, request);
  }
 
  template <typename DeleteModelBiasJobDefinitionRequestT = Model::DeleteModelBiasJobDefinitionRequest>
  void DeleteModelBiasJobDefinitionAsync(const DeleteModelBiasJobDefinitionRequestT& request,
                                         const DeleteModelBiasJobDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteModelBiasJobDefinition, request, handler, context);
  }
 
  virtual Model::DeleteModelCardOutcome DeleteModelCard(const Model::DeleteModelCardRequest& request) const;
 
  template <typename DeleteModelCardRequestT = Model::DeleteModelCardRequest>
  Model::DeleteModelCardOutcomeCallable DeleteModelCardCallable(const DeleteModelCardRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteModelCard, request);
  }
 
  template <typename DeleteModelCardRequestT = Model::DeleteModelCardRequest>
  void DeleteModelCardAsync(const DeleteModelCardRequestT& request, const DeleteModelCardResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteModelCard, request, handler, context);
  }
 
  virtual Model::DeleteModelExplainabilityJobDefinitionOutcome DeleteModelExplainabilityJobDefinition(
      const Model::DeleteModelExplainabilityJobDefinitionRequest& request) const;
 
  template <typename DeleteModelExplainabilityJobDefinitionRequestT = Model::DeleteModelExplainabilityJobDefinitionRequest>
  Model::DeleteModelExplainabilityJobDefinitionOutcomeCallable DeleteModelExplainabilityJobDefinitionCallable(
      const DeleteModelExplainabilityJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteModelExplainabilityJobDefinition, request);
  }
 
  template <typename DeleteModelExplainabilityJobDefinitionRequestT = Model::DeleteModelExplainabilityJobDefinitionRequest>
  void DeleteModelExplainabilityJobDefinitionAsync(const DeleteModelExplainabilityJobDefinitionRequestT& request,
                                                   const DeleteModelExplainabilityJobDefinitionResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteModelExplainabilityJobDefinition, request, handler, context);
  }
 
  virtual Model::DeleteModelPackageOutcome DeleteModelPackage(const Model::DeleteModelPackageRequest& request) const;
 
  template <typename DeleteModelPackageRequestT = Model::DeleteModelPackageRequest>
  Model::DeleteModelPackageOutcomeCallable DeleteModelPackageCallable(const DeleteModelPackageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteModelPackage, request);
  }
 
  template <typename DeleteModelPackageRequestT = Model::DeleteModelPackageRequest>
  void DeleteModelPackageAsync(const DeleteModelPackageRequestT& request, const DeleteModelPackageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteModelPackage, request, handler, context);
  }
 
  virtual Model::DeleteModelPackageGroupOutcome DeleteModelPackageGroup(const Model::DeleteModelPackageGroupRequest& request) const;
 
  template <typename DeleteModelPackageGroupRequestT = Model::DeleteModelPackageGroupRequest>
  Model::DeleteModelPackageGroupOutcomeCallable DeleteModelPackageGroupCallable(const DeleteModelPackageGroupRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteModelPackageGroup, request);
  }
 
  template <typename DeleteModelPackageGroupRequestT = Model::DeleteModelPackageGroupRequest>
  void DeleteModelPackageGroupAsync(const DeleteModelPackageGroupRequestT& request,
                                    const DeleteModelPackageGroupResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteModelPackageGroup, request, handler, context);
  }
 
  virtual Model::DeleteModelPackageGroupPolicyOutcome DeleteModelPackageGroupPolicy(
      const Model::DeleteModelPackageGroupPolicyRequest& request) const;
 
  template <typename DeleteModelPackageGroupPolicyRequestT = Model::DeleteModelPackageGroupPolicyRequest>
  Model::DeleteModelPackageGroupPolicyOutcomeCallable DeleteModelPackageGroupPolicyCallable(
      const DeleteModelPackageGroupPolicyRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteModelPackageGroupPolicy, request);
  }
 
  template <typename DeleteModelPackageGroupPolicyRequestT = Model::DeleteModelPackageGroupPolicyRequest>
  void DeleteModelPackageGroupPolicyAsync(const DeleteModelPackageGroupPolicyRequestT& request,
                                          const DeleteModelPackageGroupPolicyResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteModelPackageGroupPolicy, request, handler, context);
  }
 
  virtual Model::DeleteModelQualityJobDefinitionOutcome DeleteModelQualityJobDefinition(
      const Model::DeleteModelQualityJobDefinitionRequest& request) const;
 
  template <typename DeleteModelQualityJobDefinitionRequestT = Model::DeleteModelQualityJobDefinitionRequest>
  Model::DeleteModelQualityJobDefinitionOutcomeCallable DeleteModelQualityJobDefinitionCallable(
      const DeleteModelQualityJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteModelQualityJobDefinition, request);
  }
 
  template <typename DeleteModelQualityJobDefinitionRequestT = Model::DeleteModelQualityJobDefinitionRequest>
  void DeleteModelQualityJobDefinitionAsync(const DeleteModelQualityJobDefinitionRequestT& request,
                                            const DeleteModelQualityJobDefinitionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteModelQualityJobDefinition, request, handler, context);
  }
 
  virtual Model::DeleteMonitoringScheduleOutcome DeleteMonitoringSchedule(const Model::DeleteMonitoringScheduleRequest& request) const;
 
  template <typename DeleteMonitoringScheduleRequestT = Model::DeleteMonitoringScheduleRequest>
  Model::DeleteMonitoringScheduleOutcomeCallable DeleteMonitoringScheduleCallable(const DeleteMonitoringScheduleRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteMonitoringSchedule, request);
  }
 
  template <typename DeleteMonitoringScheduleRequestT = Model::DeleteMonitoringScheduleRequest>
  void DeleteMonitoringScheduleAsync(const DeleteMonitoringScheduleRequestT& request,
                                     const DeleteMonitoringScheduleResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteMonitoringSchedule, request, handler, context);
  }
 
  virtual Model::DeleteNotebookInstanceOutcome DeleteNotebookInstance(const Model::DeleteNotebookInstanceRequest& request) const;
 
  template <typename DeleteNotebookInstanceRequestT = Model::DeleteNotebookInstanceRequest>
  Model::DeleteNotebookInstanceOutcomeCallable DeleteNotebookInstanceCallable(const DeleteNotebookInstanceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteNotebookInstance, request);
  }
 
  template <typename DeleteNotebookInstanceRequestT = Model::DeleteNotebookInstanceRequest>
  void DeleteNotebookInstanceAsync(const DeleteNotebookInstanceRequestT& request,
                                   const DeleteNotebookInstanceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteNotebookInstance, request, handler, context);
  }
 
  virtual Model::DeleteNotebookInstanceLifecycleConfigOutcome DeleteNotebookInstanceLifecycleConfig(
      const Model::DeleteNotebookInstanceLifecycleConfigRequest& request) const;
 
  template <typename DeleteNotebookInstanceLifecycleConfigRequestT = Model::DeleteNotebookInstanceLifecycleConfigRequest>
  Model::DeleteNotebookInstanceLifecycleConfigOutcomeCallable DeleteNotebookInstanceLifecycleConfigCallable(
      const DeleteNotebookInstanceLifecycleConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteNotebookInstanceLifecycleConfig, request);
  }
 
  template <typename DeleteNotebookInstanceLifecycleConfigRequestT = Model::DeleteNotebookInstanceLifecycleConfigRequest>
  void DeleteNotebookInstanceLifecycleConfigAsync(const DeleteNotebookInstanceLifecycleConfigRequestT& request,
                                                  const DeleteNotebookInstanceLifecycleConfigResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteNotebookInstanceLifecycleConfig, request, handler, context);
  }
 
  virtual Model::DeleteOptimizationJobOutcome DeleteOptimizationJob(const Model::DeleteOptimizationJobRequest& request) const;
 
  template <typename DeleteOptimizationJobRequestT = Model::DeleteOptimizationJobRequest>
  Model::DeleteOptimizationJobOutcomeCallable DeleteOptimizationJobCallable(const DeleteOptimizationJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteOptimizationJob, request);
  }
 
  template <typename DeleteOptimizationJobRequestT = Model::DeleteOptimizationJobRequest>
  void DeleteOptimizationJobAsync(const DeleteOptimizationJobRequestT& request, const DeleteOptimizationJobResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteOptimizationJob, request, handler, context);
  }
 
  virtual Model::DeletePartnerAppOutcome DeletePartnerApp(const Model::DeletePartnerAppRequest& request) const;
 
  template <typename DeletePartnerAppRequestT = Model::DeletePartnerAppRequest>
  Model::DeletePartnerAppOutcomeCallable DeletePartnerAppCallable(const DeletePartnerAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeletePartnerApp, request);
  }
 
  template <typename DeletePartnerAppRequestT = Model::DeletePartnerAppRequest>
  void DeletePartnerAppAsync(const DeletePartnerAppRequestT& request, const DeletePartnerAppResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeletePartnerApp, request, handler, context);
  }
 
  virtual Model::DeletePipelineOutcome DeletePipeline(const Model::DeletePipelineRequest& request) const;
 
  template <typename DeletePipelineRequestT = Model::DeletePipelineRequest>
  Model::DeletePipelineOutcomeCallable DeletePipelineCallable(const DeletePipelineRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeletePipeline, request);
  }
 
  template <typename DeletePipelineRequestT = Model::DeletePipelineRequest>
  void DeletePipelineAsync(const DeletePipelineRequestT& request, const DeletePipelineResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeletePipeline, request, handler, context);
  }
 
  virtual Model::DeleteProcessingJobOutcome DeleteProcessingJob(const Model::DeleteProcessingJobRequest& request) const;
 
  template <typename DeleteProcessingJobRequestT = Model::DeleteProcessingJobRequest>
  Model::DeleteProcessingJobOutcomeCallable DeleteProcessingJobCallable(const DeleteProcessingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteProcessingJob, request);
  }
 
  template <typename DeleteProcessingJobRequestT = Model::DeleteProcessingJobRequest>
  void DeleteProcessingJobAsync(const DeleteProcessingJobRequestT& request, const DeleteProcessingJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteProcessingJob, request, handler, context);
  }
 
  virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const;
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteProject, request);
  }
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteProject, request, handler, context);
  }
 
  virtual Model::DeleteSpaceOutcome DeleteSpace(const Model::DeleteSpaceRequest& request) const;
 
  template <typename DeleteSpaceRequestT = Model::DeleteSpaceRequest>
  Model::DeleteSpaceOutcomeCallable DeleteSpaceCallable(const DeleteSpaceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteSpace, request);
  }
 
  template <typename DeleteSpaceRequestT = Model::DeleteSpaceRequest>
  void DeleteSpaceAsync(const DeleteSpaceRequestT& request, const DeleteSpaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteSpace, request, handler, context);
  }
 
  virtual Model::DeleteStudioLifecycleConfigOutcome DeleteStudioLifecycleConfig(
      const Model::DeleteStudioLifecycleConfigRequest& request) const;
 
  template <typename DeleteStudioLifecycleConfigRequestT = Model::DeleteStudioLifecycleConfigRequest>
  Model::DeleteStudioLifecycleConfigOutcomeCallable DeleteStudioLifecycleConfigCallable(
      const DeleteStudioLifecycleConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteStudioLifecycleConfig, request);
  }
 
  template <typename DeleteStudioLifecycleConfigRequestT = Model::DeleteStudioLifecycleConfigRequest>
  void DeleteStudioLifecycleConfigAsync(const DeleteStudioLifecycleConfigRequestT& request,
                                        const DeleteStudioLifecycleConfigResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteStudioLifecycleConfig, request, handler, context);
  }
 
  virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const;
 
  template <typename DeleteTagsRequestT = Model::DeleteTagsRequest>
  Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteTags, request);
  }
 
  template <typename DeleteTagsRequestT = Model::DeleteTagsRequest>
  void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteTags, request, handler, context);
  }
 
  virtual Model::DeleteTrainingJobOutcome DeleteTrainingJob(const Model::DeleteTrainingJobRequest& request) const;
 
  template <typename DeleteTrainingJobRequestT = Model::DeleteTrainingJobRequest>
  Model::DeleteTrainingJobOutcomeCallable DeleteTrainingJobCallable(const DeleteTrainingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteTrainingJob, request);
  }
 
  template <typename DeleteTrainingJobRequestT = Model::DeleteTrainingJobRequest>
  void DeleteTrainingJobAsync(const DeleteTrainingJobRequestT& request, const DeleteTrainingJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteTrainingJob, request, handler, context);
  }
 
  virtual Model::DeleteTrialOutcome DeleteTrial(const Model::DeleteTrialRequest& request) const;
 
  template <typename DeleteTrialRequestT = Model::DeleteTrialRequest>
  Model::DeleteTrialOutcomeCallable DeleteTrialCallable(const DeleteTrialRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteTrial, request);
  }
 
  template <typename DeleteTrialRequestT = Model::DeleteTrialRequest>
  void DeleteTrialAsync(const DeleteTrialRequestT& request, const DeleteTrialResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteTrial, request, handler, context);
  }
 
  virtual Model::DeleteTrialComponentOutcome DeleteTrialComponent(const Model::DeleteTrialComponentRequest& request) const;
 
  template <typename DeleteTrialComponentRequestT = Model::DeleteTrialComponentRequest>
  Model::DeleteTrialComponentOutcomeCallable DeleteTrialComponentCallable(const DeleteTrialComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteTrialComponent, request);
  }
 
  template <typename DeleteTrialComponentRequestT = Model::DeleteTrialComponentRequest>
  void DeleteTrialComponentAsync(const DeleteTrialComponentRequestT& request, const DeleteTrialComponentResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteTrialComponent, request, handler, context);
  }
 
  virtual Model::DeleteUserProfileOutcome DeleteUserProfile(const Model::DeleteUserProfileRequest& request) const;
 
  template <typename DeleteUserProfileRequestT = Model::DeleteUserProfileRequest>
  Model::DeleteUserProfileOutcomeCallable DeleteUserProfileCallable(const DeleteUserProfileRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteUserProfile, request);
  }
 
  template <typename DeleteUserProfileRequestT = Model::DeleteUserProfileRequest>
  void DeleteUserProfileAsync(const DeleteUserProfileRequestT& request, const DeleteUserProfileResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteUserProfile, request, handler, context);
  }
 
  virtual Model::DeleteWorkforceOutcome DeleteWorkforce(const Model::DeleteWorkforceRequest& request) const;
 
  template <typename DeleteWorkforceRequestT = Model::DeleteWorkforceRequest>
  Model::DeleteWorkforceOutcomeCallable DeleteWorkforceCallable(const DeleteWorkforceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteWorkforce, request);
  }
 
  template <typename DeleteWorkforceRequestT = Model::DeleteWorkforceRequest>
  void DeleteWorkforceAsync(const DeleteWorkforceRequestT& request, const DeleteWorkforceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteWorkforce, request, handler, context);
  }
 
  virtual Model::DeleteWorkteamOutcome DeleteWorkteam(const Model::DeleteWorkteamRequest& request) const;
 
  template <typename DeleteWorkteamRequestT = Model::DeleteWorkteamRequest>
  Model::DeleteWorkteamOutcomeCallable DeleteWorkteamCallable(const DeleteWorkteamRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeleteWorkteam, request);
  }
 
  template <typename DeleteWorkteamRequestT = Model::DeleteWorkteamRequest>
  void DeleteWorkteamAsync(const DeleteWorkteamRequestT& request, const DeleteWorkteamResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeleteWorkteam, request, handler, context);
  }
 
  virtual Model::DeregisterDevicesOutcome DeregisterDevices(const Model::DeregisterDevicesRequest& request) const;
 
  template <typename DeregisterDevicesRequestT = Model::DeregisterDevicesRequest>
  Model::DeregisterDevicesOutcomeCallable DeregisterDevicesCallable(const DeregisterDevicesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DeregisterDevices, request);
  }
 
  template <typename DeregisterDevicesRequestT = Model::DeregisterDevicesRequest>
  void DeregisterDevicesAsync(const DeregisterDevicesRequestT& request, const DeregisterDevicesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DeregisterDevices, request, handler, context);
  }
 
  virtual Model::DescribeActionOutcome DescribeAction(const Model::DescribeActionRequest& request) const;
 
  template <typename DescribeActionRequestT = Model::DescribeActionRequest>
  Model::DescribeActionOutcomeCallable DescribeActionCallable(const DescribeActionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeAction, request);
  }
 
  template <typename DescribeActionRequestT = Model::DescribeActionRequest>
  void DescribeActionAsync(const DescribeActionRequestT& request, const DescribeActionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeAction, request, handler, context);
  }
 
  virtual Model::DescribeAlgorithmOutcome DescribeAlgorithm(const Model::DescribeAlgorithmRequest& request) const;
 
  template <typename DescribeAlgorithmRequestT = Model::DescribeAlgorithmRequest>
  Model::DescribeAlgorithmOutcomeCallable DescribeAlgorithmCallable(const DescribeAlgorithmRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeAlgorithm, request);
  }
 
  template <typename DescribeAlgorithmRequestT = Model::DescribeAlgorithmRequest>
  void DescribeAlgorithmAsync(const DescribeAlgorithmRequestT& request, const DescribeAlgorithmResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeAlgorithm, request, handler, context);
  }
 
  virtual Model::DescribeAppOutcome DescribeApp(const Model::DescribeAppRequest& request) const;
 
  template <typename DescribeAppRequestT = Model::DescribeAppRequest>
  Model::DescribeAppOutcomeCallable DescribeAppCallable(const DescribeAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeApp, request);
  }
 
  template <typename DescribeAppRequestT = Model::DescribeAppRequest>
  void DescribeAppAsync(const DescribeAppRequestT& request, const DescribeAppResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeApp, request, handler, context);
  }
 
  virtual Model::DescribeAppImageConfigOutcome DescribeAppImageConfig(const Model::DescribeAppImageConfigRequest& request) const;
 
  template <typename DescribeAppImageConfigRequestT = Model::DescribeAppImageConfigRequest>
  Model::DescribeAppImageConfigOutcomeCallable DescribeAppImageConfigCallable(const DescribeAppImageConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeAppImageConfig, request);
  }
 
  template <typename DescribeAppImageConfigRequestT = Model::DescribeAppImageConfigRequest>
  void DescribeAppImageConfigAsync(const DescribeAppImageConfigRequestT& request,
                                   const DescribeAppImageConfigResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeAppImageConfig, request, handler, context);
  }
 
  virtual Model::DescribeArtifactOutcome DescribeArtifact(const Model::DescribeArtifactRequest& request) const;
 
  template <typename DescribeArtifactRequestT = Model::DescribeArtifactRequest>
  Model::DescribeArtifactOutcomeCallable DescribeArtifactCallable(const DescribeArtifactRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeArtifact, request);
  }
 
  template <typename DescribeArtifactRequestT = Model::DescribeArtifactRequest>
  void DescribeArtifactAsync(const DescribeArtifactRequestT& request, const DescribeArtifactResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeArtifact, request, handler, context);
  }
 
  virtual Model::DescribeAutoMLJobOutcome DescribeAutoMLJob(const Model::DescribeAutoMLJobRequest& request) const;
 
  template <typename DescribeAutoMLJobRequestT = Model::DescribeAutoMLJobRequest>
  Model::DescribeAutoMLJobOutcomeCallable DescribeAutoMLJobCallable(const DescribeAutoMLJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeAutoMLJob, request);
  }
 
  template <typename DescribeAutoMLJobRequestT = Model::DescribeAutoMLJobRequest>
  void DescribeAutoMLJobAsync(const DescribeAutoMLJobRequestT& request, const DescribeAutoMLJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeAutoMLJob, request, handler, context);
  }
 
  virtual Model::DescribeAutoMLJobV2Outcome DescribeAutoMLJobV2(const Model::DescribeAutoMLJobV2Request& request) const;
 
  template <typename DescribeAutoMLJobV2RequestT = Model::DescribeAutoMLJobV2Request>
  Model::DescribeAutoMLJobV2OutcomeCallable DescribeAutoMLJobV2Callable(const DescribeAutoMLJobV2RequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeAutoMLJobV2, request);
  }
 
  template <typename DescribeAutoMLJobV2RequestT = Model::DescribeAutoMLJobV2Request>
  void DescribeAutoMLJobV2Async(const DescribeAutoMLJobV2RequestT& request, const DescribeAutoMLJobV2ResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeAutoMLJobV2, request, handler, context);
  }
 
  virtual Model::DescribeClusterOutcome DescribeCluster(const Model::DescribeClusterRequest& request) const;
 
  template <typename DescribeClusterRequestT = Model::DescribeClusterRequest>
  Model::DescribeClusterOutcomeCallable DescribeClusterCallable(const DescribeClusterRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeCluster, request);
  }
 
  template <typename DescribeClusterRequestT = Model::DescribeClusterRequest>
  void DescribeClusterAsync(const DescribeClusterRequestT& request, const DescribeClusterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeCluster, request, handler, context);
  }
 
  virtual Model::DescribeClusterEventOutcome DescribeClusterEvent(const Model::DescribeClusterEventRequest& request) const;
 
  template <typename DescribeClusterEventRequestT = Model::DescribeClusterEventRequest>
  Model::DescribeClusterEventOutcomeCallable DescribeClusterEventCallable(const DescribeClusterEventRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeClusterEvent, request);
  }
 
  template <typename DescribeClusterEventRequestT = Model::DescribeClusterEventRequest>
  void DescribeClusterEventAsync(const DescribeClusterEventRequestT& request, const DescribeClusterEventResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeClusterEvent, request, handler, context);
  }
 
  virtual Model::DescribeClusterNodeOutcome DescribeClusterNode(const Model::DescribeClusterNodeRequest& request) const;
 
  template <typename DescribeClusterNodeRequestT = Model::DescribeClusterNodeRequest>
  Model::DescribeClusterNodeOutcomeCallable DescribeClusterNodeCallable(const DescribeClusterNodeRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeClusterNode, request);
  }
 
  template <typename DescribeClusterNodeRequestT = Model::DescribeClusterNodeRequest>
  void DescribeClusterNodeAsync(const DescribeClusterNodeRequestT& request, const DescribeClusterNodeResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeClusterNode, request, handler, context);
  }
 
  virtual Model::DescribeClusterSchedulerConfigOutcome DescribeClusterSchedulerConfig(
      const Model::DescribeClusterSchedulerConfigRequest& request) const;
 
  template <typename DescribeClusterSchedulerConfigRequestT = Model::DescribeClusterSchedulerConfigRequest>
  Model::DescribeClusterSchedulerConfigOutcomeCallable DescribeClusterSchedulerConfigCallable(
      const DescribeClusterSchedulerConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeClusterSchedulerConfig, request);
  }
 
  template <typename DescribeClusterSchedulerConfigRequestT = Model::DescribeClusterSchedulerConfigRequest>
  void DescribeClusterSchedulerConfigAsync(const DescribeClusterSchedulerConfigRequestT& request,
                                           const DescribeClusterSchedulerConfigResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeClusterSchedulerConfig, request, handler, context);
  }
 
  virtual Model::DescribeCodeRepositoryOutcome DescribeCodeRepository(const Model::DescribeCodeRepositoryRequest& request) const;
 
  template <typename DescribeCodeRepositoryRequestT = Model::DescribeCodeRepositoryRequest>
  Model::DescribeCodeRepositoryOutcomeCallable DescribeCodeRepositoryCallable(const DescribeCodeRepositoryRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeCodeRepository, request);
  }
 
  template <typename DescribeCodeRepositoryRequestT = Model::DescribeCodeRepositoryRequest>
  void DescribeCodeRepositoryAsync(const DescribeCodeRepositoryRequestT& request,
                                   const DescribeCodeRepositoryResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeCodeRepository, request, handler, context);
  }
 
  virtual Model::DescribeCompilationJobOutcome DescribeCompilationJob(const Model::DescribeCompilationJobRequest& request) const;
 
  template <typename DescribeCompilationJobRequestT = Model::DescribeCompilationJobRequest>
  Model::DescribeCompilationJobOutcomeCallable DescribeCompilationJobCallable(const DescribeCompilationJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeCompilationJob, request);
  }
 
  template <typename DescribeCompilationJobRequestT = Model::DescribeCompilationJobRequest>
  void DescribeCompilationJobAsync(const DescribeCompilationJobRequestT& request,
                                   const DescribeCompilationJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeCompilationJob, request, handler, context);
  }
 
  virtual Model::DescribeComputeQuotaOutcome DescribeComputeQuota(const Model::DescribeComputeQuotaRequest& request) const;
 
  template <typename DescribeComputeQuotaRequestT = Model::DescribeComputeQuotaRequest>
  Model::DescribeComputeQuotaOutcomeCallable DescribeComputeQuotaCallable(const DescribeComputeQuotaRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeComputeQuota, request);
  }
 
  template <typename DescribeComputeQuotaRequestT = Model::DescribeComputeQuotaRequest>
  void DescribeComputeQuotaAsync(const DescribeComputeQuotaRequestT& request, const DescribeComputeQuotaResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeComputeQuota, request, handler, context);
  }
 
  virtual Model::DescribeContextOutcome DescribeContext(const Model::DescribeContextRequest& request) const;
 
  template <typename DescribeContextRequestT = Model::DescribeContextRequest>
  Model::DescribeContextOutcomeCallable DescribeContextCallable(const DescribeContextRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeContext, request);
  }
 
  template <typename DescribeContextRequestT = Model::DescribeContextRequest>
  void DescribeContextAsync(const DescribeContextRequestT& request, const DescribeContextResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeContext, request, handler, context);
  }
 
  virtual Model::DescribeDataQualityJobDefinitionOutcome DescribeDataQualityJobDefinition(
      const Model::DescribeDataQualityJobDefinitionRequest& request) const;
 
  template <typename DescribeDataQualityJobDefinitionRequestT = Model::DescribeDataQualityJobDefinitionRequest>
  Model::DescribeDataQualityJobDefinitionOutcomeCallable DescribeDataQualityJobDefinitionCallable(
      const DescribeDataQualityJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeDataQualityJobDefinition, request);
  }
 
  template <typename DescribeDataQualityJobDefinitionRequestT = Model::DescribeDataQualityJobDefinitionRequest>
  void DescribeDataQualityJobDefinitionAsync(const DescribeDataQualityJobDefinitionRequestT& request,
                                             const DescribeDataQualityJobDefinitionResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeDataQualityJobDefinition, request, handler, context);
  }
 
  virtual Model::DescribeDeviceOutcome DescribeDevice(const Model::DescribeDeviceRequest& request) const;
 
  template <typename DescribeDeviceRequestT = Model::DescribeDeviceRequest>
  Model::DescribeDeviceOutcomeCallable DescribeDeviceCallable(const DescribeDeviceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeDevice, request);
  }
 
  template <typename DescribeDeviceRequestT = Model::DescribeDeviceRequest>
  void DescribeDeviceAsync(const DescribeDeviceRequestT& request, const DescribeDeviceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeDevice, request, handler, context);
  }
 
  virtual Model::DescribeDeviceFleetOutcome DescribeDeviceFleet(const Model::DescribeDeviceFleetRequest& request) const;
 
  template <typename DescribeDeviceFleetRequestT = Model::DescribeDeviceFleetRequest>
  Model::DescribeDeviceFleetOutcomeCallable DescribeDeviceFleetCallable(const DescribeDeviceFleetRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeDeviceFleet, request);
  }
 
  template <typename DescribeDeviceFleetRequestT = Model::DescribeDeviceFleetRequest>
  void DescribeDeviceFleetAsync(const DescribeDeviceFleetRequestT& request, const DescribeDeviceFleetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeDeviceFleet, request, handler, context);
  }
 
  virtual Model::DescribeDomainOutcome DescribeDomain(const Model::DescribeDomainRequest& request) const;
 
  template <typename DescribeDomainRequestT = Model::DescribeDomainRequest>
  Model::DescribeDomainOutcomeCallable DescribeDomainCallable(const DescribeDomainRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeDomain, request);
  }
 
  template <typename DescribeDomainRequestT = Model::DescribeDomainRequest>
  void DescribeDomainAsync(const DescribeDomainRequestT& request, const DescribeDomainResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeDomain, request, handler, context);
  }
 
  virtual Model::DescribeEdgeDeploymentPlanOutcome DescribeEdgeDeploymentPlan(
      const Model::DescribeEdgeDeploymentPlanRequest& request) const;
 
  template <typename DescribeEdgeDeploymentPlanRequestT = Model::DescribeEdgeDeploymentPlanRequest>
  Model::DescribeEdgeDeploymentPlanOutcomeCallable DescribeEdgeDeploymentPlanCallable(
      const DescribeEdgeDeploymentPlanRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeEdgeDeploymentPlan, request);
  }
 
  template <typename DescribeEdgeDeploymentPlanRequestT = Model::DescribeEdgeDeploymentPlanRequest>
  void DescribeEdgeDeploymentPlanAsync(const DescribeEdgeDeploymentPlanRequestT& request,
                                       const DescribeEdgeDeploymentPlanResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeEdgeDeploymentPlan, request, handler, context);
  }
 
  virtual Model::DescribeEdgePackagingJobOutcome DescribeEdgePackagingJob(const Model::DescribeEdgePackagingJobRequest& request) const;
 
  template <typename DescribeEdgePackagingJobRequestT = Model::DescribeEdgePackagingJobRequest>
  Model::DescribeEdgePackagingJobOutcomeCallable DescribeEdgePackagingJobCallable(const DescribeEdgePackagingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeEdgePackagingJob, request);
  }
 
  template <typename DescribeEdgePackagingJobRequestT = Model::DescribeEdgePackagingJobRequest>
  void DescribeEdgePackagingJobAsync(const DescribeEdgePackagingJobRequestT& request,
                                     const DescribeEdgePackagingJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeEdgePackagingJob, request, handler, context);
  }
 
  virtual Model::DescribeEndpointOutcome DescribeEndpoint(const Model::DescribeEndpointRequest& request) const;
 
  template <typename DescribeEndpointRequestT = Model::DescribeEndpointRequest>
  Model::DescribeEndpointOutcomeCallable DescribeEndpointCallable(const DescribeEndpointRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeEndpoint, request);
  }
 
  template <typename DescribeEndpointRequestT = Model::DescribeEndpointRequest>
  void DescribeEndpointAsync(const DescribeEndpointRequestT& request, const DescribeEndpointResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeEndpoint, request, handler, context);
  }
 
  virtual Model::DescribeEndpointConfigOutcome DescribeEndpointConfig(const Model::DescribeEndpointConfigRequest& request) const;
 
  template <typename DescribeEndpointConfigRequestT = Model::DescribeEndpointConfigRequest>
  Model::DescribeEndpointConfigOutcomeCallable DescribeEndpointConfigCallable(const DescribeEndpointConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeEndpointConfig, request);
  }
 
  template <typename DescribeEndpointConfigRequestT = Model::DescribeEndpointConfigRequest>
  void DescribeEndpointConfigAsync(const DescribeEndpointConfigRequestT& request,
                                   const DescribeEndpointConfigResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeEndpointConfig, request, handler, context);
  }
 
  virtual Model::DescribeExperimentOutcome DescribeExperiment(const Model::DescribeExperimentRequest& request) const;
 
  template <typename DescribeExperimentRequestT = Model::DescribeExperimentRequest>
  Model::DescribeExperimentOutcomeCallable DescribeExperimentCallable(const DescribeExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeExperiment, request);
  }
 
  template <typename DescribeExperimentRequestT = Model::DescribeExperimentRequest>
  void DescribeExperimentAsync(const DescribeExperimentRequestT& request, const DescribeExperimentResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeExperiment, request, handler, context);
  }
 
  virtual Model::DescribeFeatureGroupOutcome DescribeFeatureGroup(const Model::DescribeFeatureGroupRequest& request) const;
 
  template <typename DescribeFeatureGroupRequestT = Model::DescribeFeatureGroupRequest>
  Model::DescribeFeatureGroupOutcomeCallable DescribeFeatureGroupCallable(const DescribeFeatureGroupRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeFeatureGroup, request);
  }
 
  template <typename DescribeFeatureGroupRequestT = Model::DescribeFeatureGroupRequest>
  void DescribeFeatureGroupAsync(const DescribeFeatureGroupRequestT& request, const DescribeFeatureGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeFeatureGroup, request, handler, context);
  }
 
  virtual Model::DescribeFeatureMetadataOutcome DescribeFeatureMetadata(const Model::DescribeFeatureMetadataRequest& request) const;
 
  template <typename DescribeFeatureMetadataRequestT = Model::DescribeFeatureMetadataRequest>
  Model::DescribeFeatureMetadataOutcomeCallable DescribeFeatureMetadataCallable(const DescribeFeatureMetadataRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeFeatureMetadata, request);
  }
 
  template <typename DescribeFeatureMetadataRequestT = Model::DescribeFeatureMetadataRequest>
  void DescribeFeatureMetadataAsync(const DescribeFeatureMetadataRequestT& request,
                                    const DescribeFeatureMetadataResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeFeatureMetadata, request, handler, context);
  }
 
  virtual Model::DescribeFlowDefinitionOutcome DescribeFlowDefinition(const Model::DescribeFlowDefinitionRequest& request) const;
 
  template <typename DescribeFlowDefinitionRequestT = Model::DescribeFlowDefinitionRequest>
  Model::DescribeFlowDefinitionOutcomeCallable DescribeFlowDefinitionCallable(const DescribeFlowDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeFlowDefinition, request);
  }
 
  template <typename DescribeFlowDefinitionRequestT = Model::DescribeFlowDefinitionRequest>
  void DescribeFlowDefinitionAsync(const DescribeFlowDefinitionRequestT& request,
                                   const DescribeFlowDefinitionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeFlowDefinition, request, handler, context);
  }
 
  virtual Model::DescribeHubOutcome DescribeHub(const Model::DescribeHubRequest& request) const;
 
  template <typename DescribeHubRequestT = Model::DescribeHubRequest>
  Model::DescribeHubOutcomeCallable DescribeHubCallable(const DescribeHubRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeHub, request);
  }
 
  template <typename DescribeHubRequestT = Model::DescribeHubRequest>
  void DescribeHubAsync(const DescribeHubRequestT& request, const DescribeHubResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeHub, request, handler, context);
  }
 
  virtual Model::DescribeHubContentOutcome DescribeHubContent(const Model::DescribeHubContentRequest& request) const;
 
  template <typename DescribeHubContentRequestT = Model::DescribeHubContentRequest>
  Model::DescribeHubContentOutcomeCallable DescribeHubContentCallable(const DescribeHubContentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeHubContent, request);
  }
 
  template <typename DescribeHubContentRequestT = Model::DescribeHubContentRequest>
  void DescribeHubContentAsync(const DescribeHubContentRequestT& request, const DescribeHubContentResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeHubContent, request, handler, context);
  }
 
  virtual Model::DescribeHumanTaskUiOutcome DescribeHumanTaskUi(const Model::DescribeHumanTaskUiRequest& request) const;
 
  template <typename DescribeHumanTaskUiRequestT = Model::DescribeHumanTaskUiRequest>
  Model::DescribeHumanTaskUiOutcomeCallable DescribeHumanTaskUiCallable(const DescribeHumanTaskUiRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeHumanTaskUi, request);
  }
 
  template <typename DescribeHumanTaskUiRequestT = Model::DescribeHumanTaskUiRequest>
  void DescribeHumanTaskUiAsync(const DescribeHumanTaskUiRequestT& request, const DescribeHumanTaskUiResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeHumanTaskUi, request, handler, context);
  }
 
  virtual Model::DescribeHyperParameterTuningJobOutcome DescribeHyperParameterTuningJob(
      const Model::DescribeHyperParameterTuningJobRequest& request) const;
 
  template <typename DescribeHyperParameterTuningJobRequestT = Model::DescribeHyperParameterTuningJobRequest>
  Model::DescribeHyperParameterTuningJobOutcomeCallable DescribeHyperParameterTuningJobCallable(
      const DescribeHyperParameterTuningJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeHyperParameterTuningJob, request);
  }
 
  template <typename DescribeHyperParameterTuningJobRequestT = Model::DescribeHyperParameterTuningJobRequest>
  void DescribeHyperParameterTuningJobAsync(const DescribeHyperParameterTuningJobRequestT& request,
                                            const DescribeHyperParameterTuningJobResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeHyperParameterTuningJob, request, handler, context);
  }
 
  virtual Model::DescribeImageOutcome DescribeImage(const Model::DescribeImageRequest& request) const;
 
  template <typename DescribeImageRequestT = Model::DescribeImageRequest>
  Model::DescribeImageOutcomeCallable DescribeImageCallable(const DescribeImageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeImage, request);
  }
 
  template <typename DescribeImageRequestT = Model::DescribeImageRequest>
  void DescribeImageAsync(const DescribeImageRequestT& request, const DescribeImageResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeImage, request, handler, context);
  }
 
  virtual Model::DescribeImageVersionOutcome DescribeImageVersion(const Model::DescribeImageVersionRequest& request) const;
 
  template <typename DescribeImageVersionRequestT = Model::DescribeImageVersionRequest>
  Model::DescribeImageVersionOutcomeCallable DescribeImageVersionCallable(const DescribeImageVersionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeImageVersion, request);
  }
 
  template <typename DescribeImageVersionRequestT = Model::DescribeImageVersionRequest>
  void DescribeImageVersionAsync(const DescribeImageVersionRequestT& request, const DescribeImageVersionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeImageVersion, request, handler, context);
  }
 
  virtual Model::DescribeInferenceComponentOutcome DescribeInferenceComponent(
      const Model::DescribeInferenceComponentRequest& request) const;
 
  template <typename DescribeInferenceComponentRequestT = Model::DescribeInferenceComponentRequest>
  Model::DescribeInferenceComponentOutcomeCallable DescribeInferenceComponentCallable(
      const DescribeInferenceComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeInferenceComponent, request);
  }
 
  template <typename DescribeInferenceComponentRequestT = Model::DescribeInferenceComponentRequest>
  void DescribeInferenceComponentAsync(const DescribeInferenceComponentRequestT& request,
                                       const DescribeInferenceComponentResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeInferenceComponent, request, handler, context);
  }
 
  virtual Model::DescribeInferenceExperimentOutcome DescribeInferenceExperiment(
      const Model::DescribeInferenceExperimentRequest& request) const;
 
  template <typename DescribeInferenceExperimentRequestT = Model::DescribeInferenceExperimentRequest>
  Model::DescribeInferenceExperimentOutcomeCallable DescribeInferenceExperimentCallable(
      const DescribeInferenceExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeInferenceExperiment, request);
  }
 
  template <typename DescribeInferenceExperimentRequestT = Model::DescribeInferenceExperimentRequest>
  void DescribeInferenceExperimentAsync(const DescribeInferenceExperimentRequestT& request,
                                        const DescribeInferenceExperimentResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeInferenceExperiment, request, handler, context);
  }
 
  virtual Model::DescribeInferenceRecommendationsJobOutcome DescribeInferenceRecommendationsJob(
      const Model::DescribeInferenceRecommendationsJobRequest& request) const;
 
  template <typename DescribeInferenceRecommendationsJobRequestT = Model::DescribeInferenceRecommendationsJobRequest>
  Model::DescribeInferenceRecommendationsJobOutcomeCallable DescribeInferenceRecommendationsJobCallable(
      const DescribeInferenceRecommendationsJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeInferenceRecommendationsJob, request);
  }
 
  template <typename DescribeInferenceRecommendationsJobRequestT = Model::DescribeInferenceRecommendationsJobRequest>
  void DescribeInferenceRecommendationsJobAsync(const DescribeInferenceRecommendationsJobRequestT& request,
                                                const DescribeInferenceRecommendationsJobResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeInferenceRecommendationsJob, request, handler, context);
  }
 
  virtual Model::DescribeLabelingJobOutcome DescribeLabelingJob(const Model::DescribeLabelingJobRequest& request) const;
 
  template <typename DescribeLabelingJobRequestT = Model::DescribeLabelingJobRequest>
  Model::DescribeLabelingJobOutcomeCallable DescribeLabelingJobCallable(const DescribeLabelingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeLabelingJob, request);
  }
 
  template <typename DescribeLabelingJobRequestT = Model::DescribeLabelingJobRequest>
  void DescribeLabelingJobAsync(const DescribeLabelingJobRequestT& request, const DescribeLabelingJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeLabelingJob, request, handler, context);
  }
 
  virtual Model::DescribeLineageGroupOutcome DescribeLineageGroup(const Model::DescribeLineageGroupRequest& request) const;
 
  template <typename DescribeLineageGroupRequestT = Model::DescribeLineageGroupRequest>
  Model::DescribeLineageGroupOutcomeCallable DescribeLineageGroupCallable(const DescribeLineageGroupRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeLineageGroup, request);
  }
 
  template <typename DescribeLineageGroupRequestT = Model::DescribeLineageGroupRequest>
  void DescribeLineageGroupAsync(const DescribeLineageGroupRequestT& request, const DescribeLineageGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeLineageGroup, request, handler, context);
  }
 
  virtual Model::DescribeMlflowAppOutcome DescribeMlflowApp(const Model::DescribeMlflowAppRequest& request) const;
 
  template <typename DescribeMlflowAppRequestT = Model::DescribeMlflowAppRequest>
  Model::DescribeMlflowAppOutcomeCallable DescribeMlflowAppCallable(const DescribeMlflowAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeMlflowApp, request);
  }
 
  template <typename DescribeMlflowAppRequestT = Model::DescribeMlflowAppRequest>
  void DescribeMlflowAppAsync(const DescribeMlflowAppRequestT& request, const DescribeMlflowAppResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeMlflowApp, request, handler, context);
  }
 
  virtual Model::DescribeMlflowTrackingServerOutcome DescribeMlflowTrackingServer(
      const Model::DescribeMlflowTrackingServerRequest& request) const;
 
  template <typename DescribeMlflowTrackingServerRequestT = Model::DescribeMlflowTrackingServerRequest>
  Model::DescribeMlflowTrackingServerOutcomeCallable DescribeMlflowTrackingServerCallable(
      const DescribeMlflowTrackingServerRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeMlflowTrackingServer, request);
  }
 
  template <typename DescribeMlflowTrackingServerRequestT = Model::DescribeMlflowTrackingServerRequest>
  void DescribeMlflowTrackingServerAsync(const DescribeMlflowTrackingServerRequestT& request,
                                         const DescribeMlflowTrackingServerResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeMlflowTrackingServer, request, handler, context);
  }
 
  virtual Model::DescribeModelOutcome DescribeModel(const Model::DescribeModelRequest& request) const;
 
  template <typename DescribeModelRequestT = Model::DescribeModelRequest>
  Model::DescribeModelOutcomeCallable DescribeModelCallable(const DescribeModelRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeModel, request);
  }
 
  template <typename DescribeModelRequestT = Model::DescribeModelRequest>
  void DescribeModelAsync(const DescribeModelRequestT& request, const DescribeModelResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeModel, request, handler, context);
  }
 
  virtual Model::DescribeModelBiasJobDefinitionOutcome DescribeModelBiasJobDefinition(
      const Model::DescribeModelBiasJobDefinitionRequest& request) const;
 
  template <typename DescribeModelBiasJobDefinitionRequestT = Model::DescribeModelBiasJobDefinitionRequest>
  Model::DescribeModelBiasJobDefinitionOutcomeCallable DescribeModelBiasJobDefinitionCallable(
      const DescribeModelBiasJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeModelBiasJobDefinition, request);
  }
 
  template <typename DescribeModelBiasJobDefinitionRequestT = Model::DescribeModelBiasJobDefinitionRequest>
  void DescribeModelBiasJobDefinitionAsync(const DescribeModelBiasJobDefinitionRequestT& request,
                                           const DescribeModelBiasJobDefinitionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeModelBiasJobDefinition, request, handler, context);
  }
 
  virtual Model::DescribeModelCardOutcome DescribeModelCard(const Model::DescribeModelCardRequest& request) const;
 
  template <typename DescribeModelCardRequestT = Model::DescribeModelCardRequest>
  Model::DescribeModelCardOutcomeCallable DescribeModelCardCallable(const DescribeModelCardRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeModelCard, request);
  }
 
  template <typename DescribeModelCardRequestT = Model::DescribeModelCardRequest>
  void DescribeModelCardAsync(const DescribeModelCardRequestT& request, const DescribeModelCardResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeModelCard, request, handler, context);
  }
 
  virtual Model::DescribeModelCardExportJobOutcome DescribeModelCardExportJob(
      const Model::DescribeModelCardExportJobRequest& request) const;
 
  template <typename DescribeModelCardExportJobRequestT = Model::DescribeModelCardExportJobRequest>
  Model::DescribeModelCardExportJobOutcomeCallable DescribeModelCardExportJobCallable(
      const DescribeModelCardExportJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeModelCardExportJob, request);
  }
 
  template <typename DescribeModelCardExportJobRequestT = Model::DescribeModelCardExportJobRequest>
  void DescribeModelCardExportJobAsync(const DescribeModelCardExportJobRequestT& request,
                                       const DescribeModelCardExportJobResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeModelCardExportJob, request, handler, context);
  }
 
  virtual Model::DescribeModelExplainabilityJobDefinitionOutcome DescribeModelExplainabilityJobDefinition(
      const Model::DescribeModelExplainabilityJobDefinitionRequest& request) const;
 
  template <typename DescribeModelExplainabilityJobDefinitionRequestT = Model::DescribeModelExplainabilityJobDefinitionRequest>
  Model::DescribeModelExplainabilityJobDefinitionOutcomeCallable DescribeModelExplainabilityJobDefinitionCallable(
      const DescribeModelExplainabilityJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeModelExplainabilityJobDefinition, request);
  }
 
  template <typename DescribeModelExplainabilityJobDefinitionRequestT = Model::DescribeModelExplainabilityJobDefinitionRequest>
  void DescribeModelExplainabilityJobDefinitionAsync(
      const DescribeModelExplainabilityJobDefinitionRequestT& request,
      const DescribeModelExplainabilityJobDefinitionResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeModelExplainabilityJobDefinition, request, handler, context);
  }
 
  virtual Model::DescribeModelPackageOutcome DescribeModelPackage(const Model::DescribeModelPackageRequest& request) const;
 
  template <typename DescribeModelPackageRequestT = Model::DescribeModelPackageRequest>
  Model::DescribeModelPackageOutcomeCallable DescribeModelPackageCallable(const DescribeModelPackageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeModelPackage, request);
  }
 
  template <typename DescribeModelPackageRequestT = Model::DescribeModelPackageRequest>
  void DescribeModelPackageAsync(const DescribeModelPackageRequestT& request, const DescribeModelPackageResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeModelPackage, request, handler, context);
  }
 
  virtual Model::DescribeModelPackageGroupOutcome DescribeModelPackageGroup(const Model::DescribeModelPackageGroupRequest& request) const;
 
  template <typename DescribeModelPackageGroupRequestT = Model::DescribeModelPackageGroupRequest>
  Model::DescribeModelPackageGroupOutcomeCallable DescribeModelPackageGroupCallable(
      const DescribeModelPackageGroupRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeModelPackageGroup, request);
  }
 
  template <typename DescribeModelPackageGroupRequestT = Model::DescribeModelPackageGroupRequest>
  void DescribeModelPackageGroupAsync(const DescribeModelPackageGroupRequestT& request,
                                      const DescribeModelPackageGroupResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeModelPackageGroup, request, handler, context);
  }
 
  virtual Model::DescribeModelQualityJobDefinitionOutcome DescribeModelQualityJobDefinition(
      const Model::DescribeModelQualityJobDefinitionRequest& request) const;
 
  template <typename DescribeModelQualityJobDefinitionRequestT = Model::DescribeModelQualityJobDefinitionRequest>
  Model::DescribeModelQualityJobDefinitionOutcomeCallable DescribeModelQualityJobDefinitionCallable(
      const DescribeModelQualityJobDefinitionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeModelQualityJobDefinition, request);
  }
 
  template <typename DescribeModelQualityJobDefinitionRequestT = Model::DescribeModelQualityJobDefinitionRequest>
  void DescribeModelQualityJobDefinitionAsync(const DescribeModelQualityJobDefinitionRequestT& request,
                                              const DescribeModelQualityJobDefinitionResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeModelQualityJobDefinition, request, handler, context);
  }
 
  virtual Model::DescribeMonitoringScheduleOutcome DescribeMonitoringSchedule(
      const Model::DescribeMonitoringScheduleRequest& request) const;
 
  template <typename DescribeMonitoringScheduleRequestT = Model::DescribeMonitoringScheduleRequest>
  Model::DescribeMonitoringScheduleOutcomeCallable DescribeMonitoringScheduleCallable(
      const DescribeMonitoringScheduleRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeMonitoringSchedule, request);
  }
 
  template <typename DescribeMonitoringScheduleRequestT = Model::DescribeMonitoringScheduleRequest>
  void DescribeMonitoringScheduleAsync(const DescribeMonitoringScheduleRequestT& request,
                                       const DescribeMonitoringScheduleResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeMonitoringSchedule, request, handler, context);
  }
 
  virtual Model::DescribeNotebookInstanceOutcome DescribeNotebookInstance(const Model::DescribeNotebookInstanceRequest& request) const;
 
  template <typename DescribeNotebookInstanceRequestT = Model::DescribeNotebookInstanceRequest>
  Model::DescribeNotebookInstanceOutcomeCallable DescribeNotebookInstanceCallable(const DescribeNotebookInstanceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeNotebookInstance, request);
  }
 
  template <typename DescribeNotebookInstanceRequestT = Model::DescribeNotebookInstanceRequest>
  void DescribeNotebookInstanceAsync(const DescribeNotebookInstanceRequestT& request,
                                     const DescribeNotebookInstanceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeNotebookInstance, request, handler, context);
  }
 
  virtual Model::DescribeNotebookInstanceLifecycleConfigOutcome DescribeNotebookInstanceLifecycleConfig(
      const Model::DescribeNotebookInstanceLifecycleConfigRequest& request) const;
 
  template <typename DescribeNotebookInstanceLifecycleConfigRequestT = Model::DescribeNotebookInstanceLifecycleConfigRequest>
  Model::DescribeNotebookInstanceLifecycleConfigOutcomeCallable DescribeNotebookInstanceLifecycleConfigCallable(
      const DescribeNotebookInstanceLifecycleConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeNotebookInstanceLifecycleConfig, request);
  }
 
  template <typename DescribeNotebookInstanceLifecycleConfigRequestT = Model::DescribeNotebookInstanceLifecycleConfigRequest>
  void DescribeNotebookInstanceLifecycleConfigAsync(const DescribeNotebookInstanceLifecycleConfigRequestT& request,
                                                    const DescribeNotebookInstanceLifecycleConfigResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeNotebookInstanceLifecycleConfig, request, handler, context);
  }
 
  virtual Model::DescribeOptimizationJobOutcome DescribeOptimizationJob(const Model::DescribeOptimizationJobRequest& request) const;
 
  template <typename DescribeOptimizationJobRequestT = Model::DescribeOptimizationJobRequest>
  Model::DescribeOptimizationJobOutcomeCallable DescribeOptimizationJobCallable(const DescribeOptimizationJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeOptimizationJob, request);
  }
 
  template <typename DescribeOptimizationJobRequestT = Model::DescribeOptimizationJobRequest>
  void DescribeOptimizationJobAsync(const DescribeOptimizationJobRequestT& request,
                                    const DescribeOptimizationJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeOptimizationJob, request, handler, context);
  }
 
  virtual Model::DescribePartnerAppOutcome DescribePartnerApp(const Model::DescribePartnerAppRequest& request) const;
 
  template <typename DescribePartnerAppRequestT = Model::DescribePartnerAppRequest>
  Model::DescribePartnerAppOutcomeCallable DescribePartnerAppCallable(const DescribePartnerAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribePartnerApp, request);
  }
 
  template <typename DescribePartnerAppRequestT = Model::DescribePartnerAppRequest>
  void DescribePartnerAppAsync(const DescribePartnerAppRequestT& request, const DescribePartnerAppResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribePartnerApp, request, handler, context);
  }
 
  virtual Model::DescribePipelineOutcome DescribePipeline(const Model::DescribePipelineRequest& request) const;
 
  template <typename DescribePipelineRequestT = Model::DescribePipelineRequest>
  Model::DescribePipelineOutcomeCallable DescribePipelineCallable(const DescribePipelineRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribePipeline, request);
  }
 
  template <typename DescribePipelineRequestT = Model::DescribePipelineRequest>
  void DescribePipelineAsync(const DescribePipelineRequestT& request, const DescribePipelineResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribePipeline, request, handler, context);
  }
 
  virtual Model::DescribePipelineDefinitionForExecutionOutcome DescribePipelineDefinitionForExecution(
      const Model::DescribePipelineDefinitionForExecutionRequest& request) const;
 
  template <typename DescribePipelineDefinitionForExecutionRequestT = Model::DescribePipelineDefinitionForExecutionRequest>
  Model::DescribePipelineDefinitionForExecutionOutcomeCallable DescribePipelineDefinitionForExecutionCallable(
      const DescribePipelineDefinitionForExecutionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribePipelineDefinitionForExecution, request);
  }
 
  template <typename DescribePipelineDefinitionForExecutionRequestT = Model::DescribePipelineDefinitionForExecutionRequest>
  void DescribePipelineDefinitionForExecutionAsync(const DescribePipelineDefinitionForExecutionRequestT& request,
                                                   const DescribePipelineDefinitionForExecutionResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribePipelineDefinitionForExecution, request, handler, context);
  }
 
  virtual Model::DescribePipelineExecutionOutcome DescribePipelineExecution(const Model::DescribePipelineExecutionRequest& request) const;
 
  template <typename DescribePipelineExecutionRequestT = Model::DescribePipelineExecutionRequest>
  Model::DescribePipelineExecutionOutcomeCallable DescribePipelineExecutionCallable(
      const DescribePipelineExecutionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribePipelineExecution, request);
  }
 
  template <typename DescribePipelineExecutionRequestT = Model::DescribePipelineExecutionRequest>
  void DescribePipelineExecutionAsync(const DescribePipelineExecutionRequestT& request,
                                      const DescribePipelineExecutionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribePipelineExecution, request, handler, context);
  }
 
  virtual Model::DescribeProcessingJobOutcome DescribeProcessingJob(const Model::DescribeProcessingJobRequest& request) const;
 
  template <typename DescribeProcessingJobRequestT = Model::DescribeProcessingJobRequest>
  Model::DescribeProcessingJobOutcomeCallable DescribeProcessingJobCallable(const DescribeProcessingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeProcessingJob, request);
  }
 
  template <typename DescribeProcessingJobRequestT = Model::DescribeProcessingJobRequest>
  void DescribeProcessingJobAsync(const DescribeProcessingJobRequestT& request, const DescribeProcessingJobResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeProcessingJob, request, handler, context);
  }
 
  virtual Model::DescribeProjectOutcome DescribeProject(const Model::DescribeProjectRequest& request) const;
 
  template <typename DescribeProjectRequestT = Model::DescribeProjectRequest>
  Model::DescribeProjectOutcomeCallable DescribeProjectCallable(const DescribeProjectRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeProject, request);
  }
 
  template <typename DescribeProjectRequestT = Model::DescribeProjectRequest>
  void DescribeProjectAsync(const DescribeProjectRequestT& request, const DescribeProjectResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeProject, request, handler, context);
  }
 
  virtual Model::DescribeReservedCapacityOutcome DescribeReservedCapacity(const Model::DescribeReservedCapacityRequest& request) const;
 
  template <typename DescribeReservedCapacityRequestT = Model::DescribeReservedCapacityRequest>
  Model::DescribeReservedCapacityOutcomeCallable DescribeReservedCapacityCallable(const DescribeReservedCapacityRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeReservedCapacity, request);
  }
 
  template <typename DescribeReservedCapacityRequestT = Model::DescribeReservedCapacityRequest>
  void DescribeReservedCapacityAsync(const DescribeReservedCapacityRequestT& request,
                                     const DescribeReservedCapacityResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeReservedCapacity, request, handler, context);
  }
 
  virtual Model::DescribeSpaceOutcome DescribeSpace(const Model::DescribeSpaceRequest& request) const;
 
  template <typename DescribeSpaceRequestT = Model::DescribeSpaceRequest>
  Model::DescribeSpaceOutcomeCallable DescribeSpaceCallable(const DescribeSpaceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeSpace, request);
  }
 
  template <typename DescribeSpaceRequestT = Model::DescribeSpaceRequest>
  void DescribeSpaceAsync(const DescribeSpaceRequestT& request, const DescribeSpaceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeSpace, request, handler, context);
  }
 
  virtual Model::DescribeStudioLifecycleConfigOutcome DescribeStudioLifecycleConfig(
      const Model::DescribeStudioLifecycleConfigRequest& request) const;
 
  template <typename DescribeStudioLifecycleConfigRequestT = Model::DescribeStudioLifecycleConfigRequest>
  Model::DescribeStudioLifecycleConfigOutcomeCallable DescribeStudioLifecycleConfigCallable(
      const DescribeStudioLifecycleConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeStudioLifecycleConfig, request);
  }
 
  template <typename DescribeStudioLifecycleConfigRequestT = Model::DescribeStudioLifecycleConfigRequest>
  void DescribeStudioLifecycleConfigAsync(const DescribeStudioLifecycleConfigRequestT& request,
                                          const DescribeStudioLifecycleConfigResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeStudioLifecycleConfig, request, handler, context);
  }
 
  virtual Model::DescribeSubscribedWorkteamOutcome DescribeSubscribedWorkteam(
      const Model::DescribeSubscribedWorkteamRequest& request) const;
 
  template <typename DescribeSubscribedWorkteamRequestT = Model::DescribeSubscribedWorkteamRequest>
  Model::DescribeSubscribedWorkteamOutcomeCallable DescribeSubscribedWorkteamCallable(
      const DescribeSubscribedWorkteamRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeSubscribedWorkteam, request);
  }
 
  template <typename DescribeSubscribedWorkteamRequestT = Model::DescribeSubscribedWorkteamRequest>
  void DescribeSubscribedWorkteamAsync(const DescribeSubscribedWorkteamRequestT& request,
                                       const DescribeSubscribedWorkteamResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeSubscribedWorkteam, request, handler, context);
  }
 
  virtual Model::DescribeTrainingJobOutcome DescribeTrainingJob(const Model::DescribeTrainingJobRequest& request) const;
 
  template <typename DescribeTrainingJobRequestT = Model::DescribeTrainingJobRequest>
  Model::DescribeTrainingJobOutcomeCallable DescribeTrainingJobCallable(const DescribeTrainingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeTrainingJob, request);
  }
 
  template <typename DescribeTrainingJobRequestT = Model::DescribeTrainingJobRequest>
  void DescribeTrainingJobAsync(const DescribeTrainingJobRequestT& request, const DescribeTrainingJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeTrainingJob, request, handler, context);
  }
 
  virtual Model::DescribeTrainingPlanOutcome DescribeTrainingPlan(const Model::DescribeTrainingPlanRequest& request) const;
 
  template <typename DescribeTrainingPlanRequestT = Model::DescribeTrainingPlanRequest>
  Model::DescribeTrainingPlanOutcomeCallable DescribeTrainingPlanCallable(const DescribeTrainingPlanRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeTrainingPlan, request);
  }
 
  template <typename DescribeTrainingPlanRequestT = Model::DescribeTrainingPlanRequest>
  void DescribeTrainingPlanAsync(const DescribeTrainingPlanRequestT& request, const DescribeTrainingPlanResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeTrainingPlan, request, handler, context);
  }
 
  virtual Model::DescribeTransformJobOutcome DescribeTransformJob(const Model::DescribeTransformJobRequest& request) const;
 
  template <typename DescribeTransformJobRequestT = Model::DescribeTransformJobRequest>
  Model::DescribeTransformJobOutcomeCallable DescribeTransformJobCallable(const DescribeTransformJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeTransformJob, request);
  }
 
  template <typename DescribeTransformJobRequestT = Model::DescribeTransformJobRequest>
  void DescribeTransformJobAsync(const DescribeTransformJobRequestT& request, const DescribeTransformJobResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeTransformJob, request, handler, context);
  }
 
  virtual Model::DescribeTrialOutcome DescribeTrial(const Model::DescribeTrialRequest& request) const;
 
  template <typename DescribeTrialRequestT = Model::DescribeTrialRequest>
  Model::DescribeTrialOutcomeCallable DescribeTrialCallable(const DescribeTrialRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeTrial, request);
  }
 
  template <typename DescribeTrialRequestT = Model::DescribeTrialRequest>
  void DescribeTrialAsync(const DescribeTrialRequestT& request, const DescribeTrialResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeTrial, request, handler, context);
  }
 
  virtual Model::DescribeTrialComponentOutcome DescribeTrialComponent(const Model::DescribeTrialComponentRequest& request) const;
 
  template <typename DescribeTrialComponentRequestT = Model::DescribeTrialComponentRequest>
  Model::DescribeTrialComponentOutcomeCallable DescribeTrialComponentCallable(const DescribeTrialComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeTrialComponent, request);
  }
 
  template <typename DescribeTrialComponentRequestT = Model::DescribeTrialComponentRequest>
  void DescribeTrialComponentAsync(const DescribeTrialComponentRequestT& request,
                                   const DescribeTrialComponentResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeTrialComponent, request, handler, context);
  }
 
  virtual Model::DescribeUserProfileOutcome DescribeUserProfile(const Model::DescribeUserProfileRequest& request) const;
 
  template <typename DescribeUserProfileRequestT = Model::DescribeUserProfileRequest>
  Model::DescribeUserProfileOutcomeCallable DescribeUserProfileCallable(const DescribeUserProfileRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeUserProfile, request);
  }
 
  template <typename DescribeUserProfileRequestT = Model::DescribeUserProfileRequest>
  void DescribeUserProfileAsync(const DescribeUserProfileRequestT& request, const DescribeUserProfileResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeUserProfile, request, handler, context);
  }
 
  virtual Model::DescribeWorkforceOutcome DescribeWorkforce(const Model::DescribeWorkforceRequest& request) const;
 
  template <typename DescribeWorkforceRequestT = Model::DescribeWorkforceRequest>
  Model::DescribeWorkforceOutcomeCallable DescribeWorkforceCallable(const DescribeWorkforceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeWorkforce, request);
  }
 
  template <typename DescribeWorkforceRequestT = Model::DescribeWorkforceRequest>
  void DescribeWorkforceAsync(const DescribeWorkforceRequestT& request, const DescribeWorkforceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeWorkforce, request, handler, context);
  }
 
  virtual Model::DescribeWorkteamOutcome DescribeWorkteam(const Model::DescribeWorkteamRequest& request) const;
 
  template <typename DescribeWorkteamRequestT = Model::DescribeWorkteamRequest>
  Model::DescribeWorkteamOutcomeCallable DescribeWorkteamCallable(const DescribeWorkteamRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DescribeWorkteam, request);
  }
 
  template <typename DescribeWorkteamRequestT = Model::DescribeWorkteamRequest>
  void DescribeWorkteamAsync(const DescribeWorkteamRequestT& request, const DescribeWorkteamResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DescribeWorkteam, request, handler, context);
  }
 
  virtual Model::DetachClusterNodeVolumeOutcome DetachClusterNodeVolume(const Model::DetachClusterNodeVolumeRequest& request) const;
 
  template <typename DetachClusterNodeVolumeRequestT = Model::DetachClusterNodeVolumeRequest>
  Model::DetachClusterNodeVolumeOutcomeCallable DetachClusterNodeVolumeCallable(const DetachClusterNodeVolumeRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DetachClusterNodeVolume, request);
  }
 
  template <typename DetachClusterNodeVolumeRequestT = Model::DetachClusterNodeVolumeRequest>
  void DetachClusterNodeVolumeAsync(const DetachClusterNodeVolumeRequestT& request,
                                    const DetachClusterNodeVolumeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DetachClusterNodeVolume, request, handler, context);
  }
 
  virtual Model::DisableSagemakerServicecatalogPortfolioOutcome DisableSagemakerServicecatalogPortfolio(
      const Model::DisableSagemakerServicecatalogPortfolioRequest& request = {}) const;
 
  template <typename DisableSagemakerServicecatalogPortfolioRequestT = Model::DisableSagemakerServicecatalogPortfolioRequest>
  Model::DisableSagemakerServicecatalogPortfolioOutcomeCallable DisableSagemakerServicecatalogPortfolioCallable(
      const DisableSagemakerServicecatalogPortfolioRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::DisableSagemakerServicecatalogPortfolio, request);
  }
 
  template <typename DisableSagemakerServicecatalogPortfolioRequestT = Model::DisableSagemakerServicecatalogPortfolioRequest>
  void DisableSagemakerServicecatalogPortfolioAsync(const DisableSagemakerServicecatalogPortfolioResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                    const DisableSagemakerServicecatalogPortfolioRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::DisableSagemakerServicecatalogPortfolio, request, handler, context);
  }
 
  virtual Model::DisassociateTrialComponentOutcome DisassociateTrialComponent(
      const Model::DisassociateTrialComponentRequest& request) const;
 
  template <typename DisassociateTrialComponentRequestT = Model::DisassociateTrialComponentRequest>
  Model::DisassociateTrialComponentOutcomeCallable DisassociateTrialComponentCallable(
      const DisassociateTrialComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::DisassociateTrialComponent, request);
  }
 
  template <typename DisassociateTrialComponentRequestT = Model::DisassociateTrialComponentRequest>
  void DisassociateTrialComponentAsync(const DisassociateTrialComponentRequestT& request,
                                       const DisassociateTrialComponentResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::DisassociateTrialComponent, request, handler, context);
  }
 
  virtual Model::EnableSagemakerServicecatalogPortfolioOutcome EnableSagemakerServicecatalogPortfolio(
      const Model::EnableSagemakerServicecatalogPortfolioRequest& request = {}) const;
 
  template <typename EnableSagemakerServicecatalogPortfolioRequestT = Model::EnableSagemakerServicecatalogPortfolioRequest>
  Model::EnableSagemakerServicecatalogPortfolioOutcomeCallable EnableSagemakerServicecatalogPortfolioCallable(
      const EnableSagemakerServicecatalogPortfolioRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::EnableSagemakerServicecatalogPortfolio, request);
  }
 
  template <typename EnableSagemakerServicecatalogPortfolioRequestT = Model::EnableSagemakerServicecatalogPortfolioRequest>
  void EnableSagemakerServicecatalogPortfolioAsync(const EnableSagemakerServicecatalogPortfolioResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const EnableSagemakerServicecatalogPortfolioRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::EnableSagemakerServicecatalogPortfolio, request, handler, context);
  }
 
  virtual Model::GetDeviceFleetReportOutcome GetDeviceFleetReport(const Model::GetDeviceFleetReportRequest& request) const;
 
  template <typename GetDeviceFleetReportRequestT = Model::GetDeviceFleetReportRequest>
  Model::GetDeviceFleetReportOutcomeCallable GetDeviceFleetReportCallable(const GetDeviceFleetReportRequestT& request) const {
    return SubmitCallable(&SageMakerClient::GetDeviceFleetReport, request);
  }
 
  template <typename GetDeviceFleetReportRequestT = Model::GetDeviceFleetReportRequest>
  void GetDeviceFleetReportAsync(const GetDeviceFleetReportRequestT& request, const GetDeviceFleetReportResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::GetDeviceFleetReport, request, handler, context);
  }
 
  virtual Model::GetLineageGroupPolicyOutcome GetLineageGroupPolicy(const Model::GetLineageGroupPolicyRequest& request) const;
 
  template <typename GetLineageGroupPolicyRequestT = Model::GetLineageGroupPolicyRequest>
  Model::GetLineageGroupPolicyOutcomeCallable GetLineageGroupPolicyCallable(const GetLineageGroupPolicyRequestT& request) const {
    return SubmitCallable(&SageMakerClient::GetLineageGroupPolicy, request);
  }
 
  template <typename GetLineageGroupPolicyRequestT = Model::GetLineageGroupPolicyRequest>
  void GetLineageGroupPolicyAsync(const GetLineageGroupPolicyRequestT& request, const GetLineageGroupPolicyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::GetLineageGroupPolicy, request, handler, context);
  }
 
  virtual Model::GetModelPackageGroupPolicyOutcome GetModelPackageGroupPolicy(
      const Model::GetModelPackageGroupPolicyRequest& request) const;
 
  template <typename GetModelPackageGroupPolicyRequestT = Model::GetModelPackageGroupPolicyRequest>
  Model::GetModelPackageGroupPolicyOutcomeCallable GetModelPackageGroupPolicyCallable(
      const GetModelPackageGroupPolicyRequestT& request) const {
    return SubmitCallable(&SageMakerClient::GetModelPackageGroupPolicy, request);
  }
 
  template <typename GetModelPackageGroupPolicyRequestT = Model::GetModelPackageGroupPolicyRequest>
  void GetModelPackageGroupPolicyAsync(const GetModelPackageGroupPolicyRequestT& request,
                                       const GetModelPackageGroupPolicyResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::GetModelPackageGroupPolicy, request, handler, context);
  }
 
  virtual Model::GetSagemakerServicecatalogPortfolioStatusOutcome GetSagemakerServicecatalogPortfolioStatus(
      const Model::GetSagemakerServicecatalogPortfolioStatusRequest& request = {}) const;
 
  template <typename GetSagemakerServicecatalogPortfolioStatusRequestT = Model::GetSagemakerServicecatalogPortfolioStatusRequest>
  Model::GetSagemakerServicecatalogPortfolioStatusOutcomeCallable GetSagemakerServicecatalogPortfolioStatusCallable(
      const GetSagemakerServicecatalogPortfolioStatusRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::GetSagemakerServicecatalogPortfolioStatus, request);
  }
 
  template <typename GetSagemakerServicecatalogPortfolioStatusRequestT = Model::GetSagemakerServicecatalogPortfolioStatusRequest>
  void GetSagemakerServicecatalogPortfolioStatusAsync(const GetSagemakerServicecatalogPortfolioStatusResponseReceivedHandler& handler,
                                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                      const GetSagemakerServicecatalogPortfolioStatusRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::GetSagemakerServicecatalogPortfolioStatus, request, handler, context);
  }
 
  virtual Model::GetScalingConfigurationRecommendationOutcome GetScalingConfigurationRecommendation(
      const Model::GetScalingConfigurationRecommendationRequest& request) const;
 
  template <typename GetScalingConfigurationRecommendationRequestT = Model::GetScalingConfigurationRecommendationRequest>
  Model::GetScalingConfigurationRecommendationOutcomeCallable GetScalingConfigurationRecommendationCallable(
      const GetScalingConfigurationRecommendationRequestT& request) const {
    return SubmitCallable(&SageMakerClient::GetScalingConfigurationRecommendation, request);
  }
 
  template <typename GetScalingConfigurationRecommendationRequestT = Model::GetScalingConfigurationRecommendationRequest>
  void GetScalingConfigurationRecommendationAsync(const GetScalingConfigurationRecommendationRequestT& request,
                                                  const GetScalingConfigurationRecommendationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::GetScalingConfigurationRecommendation, request, handler, context);
  }
 
  virtual Model::GetSearchSuggestionsOutcome GetSearchSuggestions(const Model::GetSearchSuggestionsRequest& request) const;
 
  template <typename GetSearchSuggestionsRequestT = Model::GetSearchSuggestionsRequest>
  Model::GetSearchSuggestionsOutcomeCallable GetSearchSuggestionsCallable(const GetSearchSuggestionsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::GetSearchSuggestions, request);
  }
 
  template <typename GetSearchSuggestionsRequestT = Model::GetSearchSuggestionsRequest>
  void GetSearchSuggestionsAsync(const GetSearchSuggestionsRequestT& request, const GetSearchSuggestionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::GetSearchSuggestions, request, handler, context);
  }
 
  virtual Model::ImportHubContentOutcome ImportHubContent(const Model::ImportHubContentRequest& request) const;
 
  template <typename ImportHubContentRequestT = Model::ImportHubContentRequest>
  Model::ImportHubContentOutcomeCallable ImportHubContentCallable(const ImportHubContentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ImportHubContent, request);
  }
 
  template <typename ImportHubContentRequestT = Model::ImportHubContentRequest>
  void ImportHubContentAsync(const ImportHubContentRequestT& request, const ImportHubContentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ImportHubContent, request, handler, context);
  }
 
  virtual Model::ListActionsOutcome ListActions(const Model::ListActionsRequest& request = {}) const;
 
  template <typename ListActionsRequestT = Model::ListActionsRequest>
  Model::ListActionsOutcomeCallable ListActionsCallable(const ListActionsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListActions, request);
  }
 
  template <typename ListActionsRequestT = Model::ListActionsRequest>
  void ListActionsAsync(const ListActionsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListActionsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListActions, request, handler, context);
  }
 
  virtual Model::ListAlgorithmsOutcome ListAlgorithms(const Model::ListAlgorithmsRequest& request = {}) const;
 
  template <typename ListAlgorithmsRequestT = Model::ListAlgorithmsRequest>
  Model::ListAlgorithmsOutcomeCallable ListAlgorithmsCallable(const ListAlgorithmsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListAlgorithms, request);
  }
 
  template <typename ListAlgorithmsRequestT = Model::ListAlgorithmsRequest>
  void ListAlgorithmsAsync(const ListAlgorithmsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListAlgorithmsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListAlgorithms, request, handler, context);
  }
 
  virtual Model::ListAliasesOutcome ListAliases(const Model::ListAliasesRequest& request) const;
 
  template <typename ListAliasesRequestT = Model::ListAliasesRequest>
  Model::ListAliasesOutcomeCallable ListAliasesCallable(const ListAliasesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListAliases, request);
  }
 
  template <typename ListAliasesRequestT = Model::ListAliasesRequest>
  void ListAliasesAsync(const ListAliasesRequestT& request, const ListAliasesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListAliases, request, handler, context);
  }
 
  virtual Model::ListAppImageConfigsOutcome ListAppImageConfigs(const Model::ListAppImageConfigsRequest& request = {}) const;
 
  template <typename ListAppImageConfigsRequestT = Model::ListAppImageConfigsRequest>
  Model::ListAppImageConfigsOutcomeCallable ListAppImageConfigsCallable(const ListAppImageConfigsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListAppImageConfigs, request);
  }
 
  template <typename ListAppImageConfigsRequestT = Model::ListAppImageConfigsRequest>
  void ListAppImageConfigsAsync(const ListAppImageConfigsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListAppImageConfigsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListAppImageConfigs, request, handler, context);
  }
 
  virtual Model::ListAppsOutcome ListApps(const Model::ListAppsRequest& request = {}) const;
 
  template <typename ListAppsRequestT = Model::ListAppsRequest>
  Model::ListAppsOutcomeCallable ListAppsCallable(const ListAppsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListApps, request);
  }
 
  template <typename ListAppsRequestT = Model::ListAppsRequest>
  void ListAppsAsync(const ListAppsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListAppsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListApps, request, handler, context);
  }
 
  virtual Model::ListArtifactsOutcome ListArtifacts(const Model::ListArtifactsRequest& request = {}) const;
 
  template <typename ListArtifactsRequestT = Model::ListArtifactsRequest>
  Model::ListArtifactsOutcomeCallable ListArtifactsCallable(const ListArtifactsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListArtifacts, request);
  }
 
  template <typename ListArtifactsRequestT = Model::ListArtifactsRequest>
  void ListArtifactsAsync(const ListArtifactsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListArtifactsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListArtifacts, request, handler, context);
  }
 
  virtual Model::ListAssociationsOutcome ListAssociations(const Model::ListAssociationsRequest& request = {}) const;
 
  template <typename ListAssociationsRequestT = Model::ListAssociationsRequest>
  Model::ListAssociationsOutcomeCallable ListAssociationsCallable(const ListAssociationsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListAssociations, request);
  }
 
  template <typename ListAssociationsRequestT = Model::ListAssociationsRequest>
  void ListAssociationsAsync(const ListAssociationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListAssociationsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListAssociations, request, handler, context);
  }
 
  virtual Model::ListAutoMLJobsOutcome ListAutoMLJobs(const Model::ListAutoMLJobsRequest& request = {}) const;
 
  template <typename ListAutoMLJobsRequestT = Model::ListAutoMLJobsRequest>
  Model::ListAutoMLJobsOutcomeCallable ListAutoMLJobsCallable(const ListAutoMLJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListAutoMLJobs, request);
  }
 
  template <typename ListAutoMLJobsRequestT = Model::ListAutoMLJobsRequest>
  void ListAutoMLJobsAsync(const ListAutoMLJobsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListAutoMLJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListAutoMLJobs, request, handler, context);
  }
 
  virtual Model::ListCandidatesForAutoMLJobOutcome ListCandidatesForAutoMLJob(
      const Model::ListCandidatesForAutoMLJobRequest& request) const;
 
  template <typename ListCandidatesForAutoMLJobRequestT = Model::ListCandidatesForAutoMLJobRequest>
  Model::ListCandidatesForAutoMLJobOutcomeCallable ListCandidatesForAutoMLJobCallable(
      const ListCandidatesForAutoMLJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListCandidatesForAutoMLJob, request);
  }
 
  template <typename ListCandidatesForAutoMLJobRequestT = Model::ListCandidatesForAutoMLJobRequest>
  void ListCandidatesForAutoMLJobAsync(const ListCandidatesForAutoMLJobRequestT& request,
                                       const ListCandidatesForAutoMLJobResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListCandidatesForAutoMLJob, request, handler, context);
  }
 
  virtual Model::ListClusterEventsOutcome ListClusterEvents(const Model::ListClusterEventsRequest& request) const;
 
  template <typename ListClusterEventsRequestT = Model::ListClusterEventsRequest>
  Model::ListClusterEventsOutcomeCallable ListClusterEventsCallable(const ListClusterEventsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListClusterEvents, request);
  }
 
  template <typename ListClusterEventsRequestT = Model::ListClusterEventsRequest>
  void ListClusterEventsAsync(const ListClusterEventsRequestT& request, const ListClusterEventsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListClusterEvents, request, handler, context);
  }
 
  virtual Model::ListClusterNodesOutcome ListClusterNodes(const Model::ListClusterNodesRequest& request) const;
 
  template <typename ListClusterNodesRequestT = Model::ListClusterNodesRequest>
  Model::ListClusterNodesOutcomeCallable ListClusterNodesCallable(const ListClusterNodesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListClusterNodes, request);
  }
 
  template <typename ListClusterNodesRequestT = Model::ListClusterNodesRequest>
  void ListClusterNodesAsync(const ListClusterNodesRequestT& request, const ListClusterNodesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListClusterNodes, request, handler, context);
  }
 
  virtual Model::ListClusterSchedulerConfigsOutcome ListClusterSchedulerConfigs(
      const Model::ListClusterSchedulerConfigsRequest& request = {}) const;
 
  template <typename ListClusterSchedulerConfigsRequestT = Model::ListClusterSchedulerConfigsRequest>
  Model::ListClusterSchedulerConfigsOutcomeCallable ListClusterSchedulerConfigsCallable(
      const ListClusterSchedulerConfigsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListClusterSchedulerConfigs, request);
  }
 
  template <typename ListClusterSchedulerConfigsRequestT = Model::ListClusterSchedulerConfigsRequest>
  void ListClusterSchedulerConfigsAsync(const ListClusterSchedulerConfigsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListClusterSchedulerConfigsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListClusterSchedulerConfigs, request, handler, context);
  }
 
  virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListClusters, request);
  }
 
  template <typename ListClustersRequestT = Model::ListClustersRequest>
  void ListClustersAsync(const ListClustersResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListClustersRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListClusters, request, handler, context);
  }
 
  virtual Model::ListCodeRepositoriesOutcome ListCodeRepositories(const Model::ListCodeRepositoriesRequest& request = {}) const;
 
  template <typename ListCodeRepositoriesRequestT = Model::ListCodeRepositoriesRequest>
  Model::ListCodeRepositoriesOutcomeCallable ListCodeRepositoriesCallable(const ListCodeRepositoriesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListCodeRepositories, request);
  }
 
  template <typename ListCodeRepositoriesRequestT = Model::ListCodeRepositoriesRequest>
  void ListCodeRepositoriesAsync(const ListCodeRepositoriesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListCodeRepositoriesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListCodeRepositories, request, handler, context);
  }
 
  virtual Model::ListCompilationJobsOutcome ListCompilationJobs(const Model::ListCompilationJobsRequest& request = {}) const;
 
  template <typename ListCompilationJobsRequestT = Model::ListCompilationJobsRequest>
  Model::ListCompilationJobsOutcomeCallable ListCompilationJobsCallable(const ListCompilationJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListCompilationJobs, request);
  }
 
  template <typename ListCompilationJobsRequestT = Model::ListCompilationJobsRequest>
  void ListCompilationJobsAsync(const ListCompilationJobsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListCompilationJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListCompilationJobs, request, handler, context);
  }
 
  virtual Model::ListComputeQuotasOutcome ListComputeQuotas(const Model::ListComputeQuotasRequest& request = {}) const;
 
  template <typename ListComputeQuotasRequestT = Model::ListComputeQuotasRequest>
  Model::ListComputeQuotasOutcomeCallable ListComputeQuotasCallable(const ListComputeQuotasRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListComputeQuotas, request);
  }
 
  template <typename ListComputeQuotasRequestT = Model::ListComputeQuotasRequest>
  void ListComputeQuotasAsync(const ListComputeQuotasResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListComputeQuotasRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListComputeQuotas, request, handler, context);
  }
 
  virtual Model::ListContextsOutcome ListContexts(const Model::ListContextsRequest& request = {}) const;
 
  template <typename ListContextsRequestT = Model::ListContextsRequest>
  Model::ListContextsOutcomeCallable ListContextsCallable(const ListContextsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListContexts, request);
  }
 
  template <typename ListContextsRequestT = Model::ListContextsRequest>
  void ListContextsAsync(const ListContextsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListContextsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListContexts, request, handler, context);
  }
 
  virtual Model::ListDataQualityJobDefinitionsOutcome ListDataQualityJobDefinitions(
      const Model::ListDataQualityJobDefinitionsRequest& request = {}) const;
 
  template <typename ListDataQualityJobDefinitionsRequestT = Model::ListDataQualityJobDefinitionsRequest>
  Model::ListDataQualityJobDefinitionsOutcomeCallable ListDataQualityJobDefinitionsCallable(
      const ListDataQualityJobDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListDataQualityJobDefinitions, request);
  }
 
  template <typename ListDataQualityJobDefinitionsRequestT = Model::ListDataQualityJobDefinitionsRequest>
  void ListDataQualityJobDefinitionsAsync(const ListDataQualityJobDefinitionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const ListDataQualityJobDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListDataQualityJobDefinitions, request, handler, context);
  }
 
  virtual Model::ListDeviceFleetsOutcome ListDeviceFleets(const Model::ListDeviceFleetsRequest& request = {}) const;
 
  template <typename ListDeviceFleetsRequestT = Model::ListDeviceFleetsRequest>
  Model::ListDeviceFleetsOutcomeCallable ListDeviceFleetsCallable(const ListDeviceFleetsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListDeviceFleets, request);
  }
 
  template <typename ListDeviceFleetsRequestT = Model::ListDeviceFleetsRequest>
  void ListDeviceFleetsAsync(const ListDeviceFleetsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListDeviceFleetsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListDeviceFleets, request, handler, context);
  }
 
  virtual Model::ListDevicesOutcome ListDevices(const Model::ListDevicesRequest& request = {}) const;
 
  template <typename ListDevicesRequestT = Model::ListDevicesRequest>
  Model::ListDevicesOutcomeCallable ListDevicesCallable(const ListDevicesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListDevices, request);
  }
 
  template <typename ListDevicesRequestT = Model::ListDevicesRequest>
  void ListDevicesAsync(const ListDevicesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListDevicesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListDevices, request, handler, context);
  }
 
  virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request = {}) const;
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListDomains, request);
  }
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  void ListDomainsAsync(const ListDomainsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListDomainsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListDomains, request, handler, context);
  }
 
  virtual Model::ListEdgeDeploymentPlansOutcome ListEdgeDeploymentPlans(const Model::ListEdgeDeploymentPlansRequest& request = {}) const;
 
  template <typename ListEdgeDeploymentPlansRequestT = Model::ListEdgeDeploymentPlansRequest>
  Model::ListEdgeDeploymentPlansOutcomeCallable ListEdgeDeploymentPlansCallable(const ListEdgeDeploymentPlansRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListEdgeDeploymentPlans, request);
  }
 
  template <typename ListEdgeDeploymentPlansRequestT = Model::ListEdgeDeploymentPlansRequest>
  void ListEdgeDeploymentPlansAsync(const ListEdgeDeploymentPlansResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListEdgeDeploymentPlansRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListEdgeDeploymentPlans, request, handler, context);
  }
 
  virtual Model::ListEdgePackagingJobsOutcome ListEdgePackagingJobs(const Model::ListEdgePackagingJobsRequest& request = {}) const;
 
  template <typename ListEdgePackagingJobsRequestT = Model::ListEdgePackagingJobsRequest>
  Model::ListEdgePackagingJobsOutcomeCallable ListEdgePackagingJobsCallable(const ListEdgePackagingJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListEdgePackagingJobs, request);
  }
 
  template <typename ListEdgePackagingJobsRequestT = Model::ListEdgePackagingJobsRequest>
  void ListEdgePackagingJobsAsync(const ListEdgePackagingJobsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListEdgePackagingJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListEdgePackagingJobs, request, handler, context);
  }
 
  virtual Model::ListEndpointConfigsOutcome ListEndpointConfigs(const Model::ListEndpointConfigsRequest& request = {}) const;
 
  template <typename ListEndpointConfigsRequestT = Model::ListEndpointConfigsRequest>
  Model::ListEndpointConfigsOutcomeCallable ListEndpointConfigsCallable(const ListEndpointConfigsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListEndpointConfigs, request);
  }
 
  template <typename ListEndpointConfigsRequestT = Model::ListEndpointConfigsRequest>
  void ListEndpointConfigsAsync(const ListEndpointConfigsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListEndpointConfigsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListEndpointConfigs, request, handler, context);
  }
 
  virtual Model::ListEndpointsOutcome ListEndpoints(const Model::ListEndpointsRequest& request = {}) const;
 
  template <typename ListEndpointsRequestT = Model::ListEndpointsRequest>
  Model::ListEndpointsOutcomeCallable ListEndpointsCallable(const ListEndpointsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListEndpoints, request);
  }
 
  template <typename ListEndpointsRequestT = Model::ListEndpointsRequest>
  void ListEndpointsAsync(const ListEndpointsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListEndpointsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListEndpoints, request, handler, context);
  }
 
  virtual Model::ListExperimentsOutcome ListExperiments(const Model::ListExperimentsRequest& request = {}) const;
 
  template <typename ListExperimentsRequestT = Model::ListExperimentsRequest>
  Model::ListExperimentsOutcomeCallable ListExperimentsCallable(const ListExperimentsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListExperiments, request);
  }
 
  template <typename ListExperimentsRequestT = Model::ListExperimentsRequest>
  void ListExperimentsAsync(const ListExperimentsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListExperimentsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListExperiments, request, handler, context);
  }
 
  virtual Model::ListFeatureGroupsOutcome ListFeatureGroups(const Model::ListFeatureGroupsRequest& request = {}) const;
 
  template <typename ListFeatureGroupsRequestT = Model::ListFeatureGroupsRequest>
  Model::ListFeatureGroupsOutcomeCallable ListFeatureGroupsCallable(const ListFeatureGroupsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListFeatureGroups, request);
  }
 
  template <typename ListFeatureGroupsRequestT = Model::ListFeatureGroupsRequest>
  void ListFeatureGroupsAsync(const ListFeatureGroupsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListFeatureGroupsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListFeatureGroups, request, handler, context);
  }
 
  virtual Model::ListFlowDefinitionsOutcome ListFlowDefinitions(const Model::ListFlowDefinitionsRequest& request = {}) const;
 
  template <typename ListFlowDefinitionsRequestT = Model::ListFlowDefinitionsRequest>
  Model::ListFlowDefinitionsOutcomeCallable ListFlowDefinitionsCallable(const ListFlowDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListFlowDefinitions, request);
  }
 
  template <typename ListFlowDefinitionsRequestT = Model::ListFlowDefinitionsRequest>
  void ListFlowDefinitionsAsync(const ListFlowDefinitionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListFlowDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListFlowDefinitions, request, handler, context);
  }
 
  virtual Model::ListHubContentVersionsOutcome ListHubContentVersions(const Model::ListHubContentVersionsRequest& request) const;
 
  template <typename ListHubContentVersionsRequestT = Model::ListHubContentVersionsRequest>
  Model::ListHubContentVersionsOutcomeCallable ListHubContentVersionsCallable(const ListHubContentVersionsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListHubContentVersions, request);
  }
 
  template <typename ListHubContentVersionsRequestT = Model::ListHubContentVersionsRequest>
  void ListHubContentVersionsAsync(const ListHubContentVersionsRequestT& request,
                                   const ListHubContentVersionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListHubContentVersions, request, handler, context);
  }
 
  virtual Model::ListHubContentsOutcome ListHubContents(const Model::ListHubContentsRequest& request) const;
 
  template <typename ListHubContentsRequestT = Model::ListHubContentsRequest>
  Model::ListHubContentsOutcomeCallable ListHubContentsCallable(const ListHubContentsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListHubContents, request);
  }
 
  template <typename ListHubContentsRequestT = Model::ListHubContentsRequest>
  void ListHubContentsAsync(const ListHubContentsRequestT& request, const ListHubContentsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListHubContents, request, handler, context);
  }
 
  virtual Model::ListHubsOutcome ListHubs(const Model::ListHubsRequest& request = {}) const;
 
  template <typename ListHubsRequestT = Model::ListHubsRequest>
  Model::ListHubsOutcomeCallable ListHubsCallable(const ListHubsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListHubs, request);
  }
 
  template <typename ListHubsRequestT = Model::ListHubsRequest>
  void ListHubsAsync(const ListHubsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListHubsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListHubs, request, handler, context);
  }
 
  virtual Model::ListHumanTaskUisOutcome ListHumanTaskUis(const Model::ListHumanTaskUisRequest& request = {}) const;
 
  template <typename ListHumanTaskUisRequestT = Model::ListHumanTaskUisRequest>
  Model::ListHumanTaskUisOutcomeCallable ListHumanTaskUisCallable(const ListHumanTaskUisRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListHumanTaskUis, request);
  }
 
  template <typename ListHumanTaskUisRequestT = Model::ListHumanTaskUisRequest>
  void ListHumanTaskUisAsync(const ListHumanTaskUisResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListHumanTaskUisRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListHumanTaskUis, request, handler, context);
  }
 
  virtual Model::ListHyperParameterTuningJobsOutcome ListHyperParameterTuningJobs(
      const Model::ListHyperParameterTuningJobsRequest& request = {}) const;
 
  template <typename ListHyperParameterTuningJobsRequestT = Model::ListHyperParameterTuningJobsRequest>
  Model::ListHyperParameterTuningJobsOutcomeCallable ListHyperParameterTuningJobsCallable(
      const ListHyperParameterTuningJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListHyperParameterTuningJobs, request);
  }
 
  template <typename ListHyperParameterTuningJobsRequestT = Model::ListHyperParameterTuningJobsRequest>
  void ListHyperParameterTuningJobsAsync(const ListHyperParameterTuningJobsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListHyperParameterTuningJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListHyperParameterTuningJobs, request, handler, context);
  }
 
  virtual Model::ListImageVersionsOutcome ListImageVersions(const Model::ListImageVersionsRequest& request) const;
 
  template <typename ListImageVersionsRequestT = Model::ListImageVersionsRequest>
  Model::ListImageVersionsOutcomeCallable ListImageVersionsCallable(const ListImageVersionsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListImageVersions, request);
  }
 
  template <typename ListImageVersionsRequestT = Model::ListImageVersionsRequest>
  void ListImageVersionsAsync(const ListImageVersionsRequestT& request, const ListImageVersionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListImageVersions, request, handler, context);
  }
 
  virtual Model::ListImagesOutcome ListImages(const Model::ListImagesRequest& request = {}) const;
 
  template <typename ListImagesRequestT = Model::ListImagesRequest>
  Model::ListImagesOutcomeCallable ListImagesCallable(const ListImagesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListImages, request);
  }
 
  template <typename ListImagesRequestT = Model::ListImagesRequest>
  void ListImagesAsync(const ListImagesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListImagesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListImages, request, handler, context);
  }
 
  virtual Model::ListInferenceComponentsOutcome ListInferenceComponents(const Model::ListInferenceComponentsRequest& request = {}) const;
 
  template <typename ListInferenceComponentsRequestT = Model::ListInferenceComponentsRequest>
  Model::ListInferenceComponentsOutcomeCallable ListInferenceComponentsCallable(const ListInferenceComponentsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListInferenceComponents, request);
  }
 
  template <typename ListInferenceComponentsRequestT = Model::ListInferenceComponentsRequest>
  void ListInferenceComponentsAsync(const ListInferenceComponentsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListInferenceComponentsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListInferenceComponents, request, handler, context);
  }
 
  virtual Model::ListInferenceExperimentsOutcome ListInferenceExperiments(const Model::ListInferenceExperimentsRequest& request = {}) const;
 
  template <typename ListInferenceExperimentsRequestT = Model::ListInferenceExperimentsRequest>
  Model::ListInferenceExperimentsOutcomeCallable ListInferenceExperimentsCallable(
      const ListInferenceExperimentsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListInferenceExperiments, request);
  }
 
  template <typename ListInferenceExperimentsRequestT = Model::ListInferenceExperimentsRequest>
  void ListInferenceExperimentsAsync(const ListInferenceExperimentsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListInferenceExperimentsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListInferenceExperiments, request, handler, context);
  }
 
  virtual Model::ListInferenceRecommendationsJobStepsOutcome ListInferenceRecommendationsJobSteps(
      const Model::ListInferenceRecommendationsJobStepsRequest& request) const;
 
  template <typename ListInferenceRecommendationsJobStepsRequestT = Model::ListInferenceRecommendationsJobStepsRequest>
  Model::ListInferenceRecommendationsJobStepsOutcomeCallable ListInferenceRecommendationsJobStepsCallable(
      const ListInferenceRecommendationsJobStepsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListInferenceRecommendationsJobSteps, request);
  }
 
  template <typename ListInferenceRecommendationsJobStepsRequestT = Model::ListInferenceRecommendationsJobStepsRequest>
  void ListInferenceRecommendationsJobStepsAsync(const ListInferenceRecommendationsJobStepsRequestT& request,
                                                 const ListInferenceRecommendationsJobStepsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListInferenceRecommendationsJobSteps, request, handler, context);
  }
 
  virtual Model::ListInferenceRecommendationsJobsOutcome ListInferenceRecommendationsJobs(
      const Model::ListInferenceRecommendationsJobsRequest& request = {}) const;
 
  template <typename ListInferenceRecommendationsJobsRequestT = Model::ListInferenceRecommendationsJobsRequest>
  Model::ListInferenceRecommendationsJobsOutcomeCallable ListInferenceRecommendationsJobsCallable(
      const ListInferenceRecommendationsJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListInferenceRecommendationsJobs, request);
  }
 
  template <typename ListInferenceRecommendationsJobsRequestT = Model::ListInferenceRecommendationsJobsRequest>
  void ListInferenceRecommendationsJobsAsync(const ListInferenceRecommendationsJobsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const ListInferenceRecommendationsJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListInferenceRecommendationsJobs, request, handler, context);
  }
 
  virtual Model::ListLabelingJobsOutcome ListLabelingJobs(const Model::ListLabelingJobsRequest& request = {}) const;
 
  template <typename ListLabelingJobsRequestT = Model::ListLabelingJobsRequest>
  Model::ListLabelingJobsOutcomeCallable ListLabelingJobsCallable(const ListLabelingJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListLabelingJobs, request);
  }
 
  template <typename ListLabelingJobsRequestT = Model::ListLabelingJobsRequest>
  void ListLabelingJobsAsync(const ListLabelingJobsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListLabelingJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListLabelingJobs, request, handler, context);
  }
 
  virtual Model::ListLabelingJobsForWorkteamOutcome ListLabelingJobsForWorkteam(
      const Model::ListLabelingJobsForWorkteamRequest& request) const;
 
  template <typename ListLabelingJobsForWorkteamRequestT = Model::ListLabelingJobsForWorkteamRequest>
  Model::ListLabelingJobsForWorkteamOutcomeCallable ListLabelingJobsForWorkteamCallable(
      const ListLabelingJobsForWorkteamRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListLabelingJobsForWorkteam, request);
  }
 
  template <typename ListLabelingJobsForWorkteamRequestT = Model::ListLabelingJobsForWorkteamRequest>
  void ListLabelingJobsForWorkteamAsync(const ListLabelingJobsForWorkteamRequestT& request,
                                        const ListLabelingJobsForWorkteamResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListLabelingJobsForWorkteam, request, handler, context);
  }
 
  virtual Model::ListLineageGroupsOutcome ListLineageGroups(const Model::ListLineageGroupsRequest& request = {}) const;
 
  template <typename ListLineageGroupsRequestT = Model::ListLineageGroupsRequest>
  Model::ListLineageGroupsOutcomeCallable ListLineageGroupsCallable(const ListLineageGroupsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListLineageGroups, request);
  }
 
  template <typename ListLineageGroupsRequestT = Model::ListLineageGroupsRequest>
  void ListLineageGroupsAsync(const ListLineageGroupsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListLineageGroupsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListLineageGroups, request, handler, context);
  }
 
  virtual Model::ListMlflowAppsOutcome ListMlflowApps(const Model::ListMlflowAppsRequest& request = {}) const;
 
  template <typename ListMlflowAppsRequestT = Model::ListMlflowAppsRequest>
  Model::ListMlflowAppsOutcomeCallable ListMlflowAppsCallable(const ListMlflowAppsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListMlflowApps, request);
  }
 
  template <typename ListMlflowAppsRequestT = Model::ListMlflowAppsRequest>
  void ListMlflowAppsAsync(const ListMlflowAppsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListMlflowAppsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListMlflowApps, request, handler, context);
  }
 
  virtual Model::ListMlflowTrackingServersOutcome ListMlflowTrackingServers(
      const Model::ListMlflowTrackingServersRequest& request = {}) const;
 
  template <typename ListMlflowTrackingServersRequestT = Model::ListMlflowTrackingServersRequest>
  Model::ListMlflowTrackingServersOutcomeCallable ListMlflowTrackingServersCallable(
      const ListMlflowTrackingServersRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListMlflowTrackingServers, request);
  }
 
  template <typename ListMlflowTrackingServersRequestT = Model::ListMlflowTrackingServersRequest>
  void ListMlflowTrackingServersAsync(const ListMlflowTrackingServersResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListMlflowTrackingServersRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListMlflowTrackingServers, request, handler, context);
  }
 
  virtual Model::ListModelBiasJobDefinitionsOutcome ListModelBiasJobDefinitions(
      const Model::ListModelBiasJobDefinitionsRequest& request = {}) const;
 
  template <typename ListModelBiasJobDefinitionsRequestT = Model::ListModelBiasJobDefinitionsRequest>
  Model::ListModelBiasJobDefinitionsOutcomeCallable ListModelBiasJobDefinitionsCallable(
      const ListModelBiasJobDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListModelBiasJobDefinitions, request);
  }
 
  template <typename ListModelBiasJobDefinitionsRequestT = Model::ListModelBiasJobDefinitionsRequest>
  void ListModelBiasJobDefinitionsAsync(const ListModelBiasJobDefinitionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListModelBiasJobDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListModelBiasJobDefinitions, request, handler, context);
  }
 
  virtual Model::ListModelCardExportJobsOutcome ListModelCardExportJobs(const Model::ListModelCardExportJobsRequest& request) const;
 
  template <typename ListModelCardExportJobsRequestT = Model::ListModelCardExportJobsRequest>
  Model::ListModelCardExportJobsOutcomeCallable ListModelCardExportJobsCallable(const ListModelCardExportJobsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListModelCardExportJobs, request);
  }
 
  template <typename ListModelCardExportJobsRequestT = Model::ListModelCardExportJobsRequest>
  void ListModelCardExportJobsAsync(const ListModelCardExportJobsRequestT& request,
                                    const ListModelCardExportJobsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListModelCardExportJobs, request, handler, context);
  }
 
  virtual Model::ListModelCardVersionsOutcome ListModelCardVersions(const Model::ListModelCardVersionsRequest& request) const;
 
  template <typename ListModelCardVersionsRequestT = Model::ListModelCardVersionsRequest>
  Model::ListModelCardVersionsOutcomeCallable ListModelCardVersionsCallable(const ListModelCardVersionsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListModelCardVersions, request);
  }
 
  template <typename ListModelCardVersionsRequestT = Model::ListModelCardVersionsRequest>
  void ListModelCardVersionsAsync(const ListModelCardVersionsRequestT& request, const ListModelCardVersionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListModelCardVersions, request, handler, context);
  }
 
  virtual Model::ListModelCardsOutcome ListModelCards(const Model::ListModelCardsRequest& request = {}) const;
 
  template <typename ListModelCardsRequestT = Model::ListModelCardsRequest>
  Model::ListModelCardsOutcomeCallable ListModelCardsCallable(const ListModelCardsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListModelCards, request);
  }
 
  template <typename ListModelCardsRequestT = Model::ListModelCardsRequest>
  void ListModelCardsAsync(const ListModelCardsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListModelCardsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListModelCards, request, handler, context);
  }
 
  virtual Model::ListModelExplainabilityJobDefinitionsOutcome ListModelExplainabilityJobDefinitions(
      const Model::ListModelExplainabilityJobDefinitionsRequest& request = {}) const;
 
  template <typename ListModelExplainabilityJobDefinitionsRequestT = Model::ListModelExplainabilityJobDefinitionsRequest>
  Model::ListModelExplainabilityJobDefinitionsOutcomeCallable ListModelExplainabilityJobDefinitionsCallable(
      const ListModelExplainabilityJobDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListModelExplainabilityJobDefinitions, request);
  }
 
  template <typename ListModelExplainabilityJobDefinitionsRequestT = Model::ListModelExplainabilityJobDefinitionsRequest>
  void ListModelExplainabilityJobDefinitionsAsync(const ListModelExplainabilityJobDefinitionsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                  const ListModelExplainabilityJobDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListModelExplainabilityJobDefinitions, request, handler, context);
  }
 
  virtual Model::ListModelMetadataOutcome ListModelMetadata(const Model::ListModelMetadataRequest& request = {}) const;
 
  template <typename ListModelMetadataRequestT = Model::ListModelMetadataRequest>
  Model::ListModelMetadataOutcomeCallable ListModelMetadataCallable(const ListModelMetadataRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListModelMetadata, request);
  }
 
  template <typename ListModelMetadataRequestT = Model::ListModelMetadataRequest>
  void ListModelMetadataAsync(const ListModelMetadataResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListModelMetadataRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListModelMetadata, request, handler, context);
  }
 
  virtual Model::ListModelPackageGroupsOutcome ListModelPackageGroups(const Model::ListModelPackageGroupsRequest& request = {}) const;
 
  template <typename ListModelPackageGroupsRequestT = Model::ListModelPackageGroupsRequest>
  Model::ListModelPackageGroupsOutcomeCallable ListModelPackageGroupsCallable(const ListModelPackageGroupsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListModelPackageGroups, request);
  }
 
  template <typename ListModelPackageGroupsRequestT = Model::ListModelPackageGroupsRequest>
  void ListModelPackageGroupsAsync(const ListModelPackageGroupsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListModelPackageGroupsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListModelPackageGroups, request, handler, context);
  }
 
  virtual Model::ListModelPackagesOutcome ListModelPackages(const Model::ListModelPackagesRequest& request = {}) const;
 
  template <typename ListModelPackagesRequestT = Model::ListModelPackagesRequest>
  Model::ListModelPackagesOutcomeCallable ListModelPackagesCallable(const ListModelPackagesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListModelPackages, request);
  }
 
  template <typename ListModelPackagesRequestT = Model::ListModelPackagesRequest>
  void ListModelPackagesAsync(const ListModelPackagesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListModelPackagesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListModelPackages, request, handler, context);
  }
 
  virtual Model::ListModelQualityJobDefinitionsOutcome ListModelQualityJobDefinitions(
      const Model::ListModelQualityJobDefinitionsRequest& request = {}) const;
 
  template <typename ListModelQualityJobDefinitionsRequestT = Model::ListModelQualityJobDefinitionsRequest>
  Model::ListModelQualityJobDefinitionsOutcomeCallable ListModelQualityJobDefinitionsCallable(
      const ListModelQualityJobDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListModelQualityJobDefinitions, request);
  }
 
  template <typename ListModelQualityJobDefinitionsRequestT = Model::ListModelQualityJobDefinitionsRequest>
  void ListModelQualityJobDefinitionsAsync(const ListModelQualityJobDefinitionsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ListModelQualityJobDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListModelQualityJobDefinitions, request, handler, context);
  }
 
  virtual Model::ListModelsOutcome ListModels(const Model::ListModelsRequest& request = {}) const;
 
  template <typename ListModelsRequestT = Model::ListModelsRequest>
  Model::ListModelsOutcomeCallable ListModelsCallable(const ListModelsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListModels, request);
  }
 
  template <typename ListModelsRequestT = Model::ListModelsRequest>
  void ListModelsAsync(const ListModelsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListModelsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListModels, request, handler, context);
  }
 
  virtual Model::ListMonitoringAlertHistoryOutcome ListMonitoringAlertHistory(
      const Model::ListMonitoringAlertHistoryRequest& request = {}) const;
 
  template <typename ListMonitoringAlertHistoryRequestT = Model::ListMonitoringAlertHistoryRequest>
  Model::ListMonitoringAlertHistoryOutcomeCallable ListMonitoringAlertHistoryCallable(
      const ListMonitoringAlertHistoryRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListMonitoringAlertHistory, request);
  }
 
  template <typename ListMonitoringAlertHistoryRequestT = Model::ListMonitoringAlertHistoryRequest>
  void ListMonitoringAlertHistoryAsync(const ListMonitoringAlertHistoryResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListMonitoringAlertHistoryRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListMonitoringAlertHistory, request, handler, context);
  }
 
  virtual Model::ListMonitoringAlertsOutcome ListMonitoringAlerts(const Model::ListMonitoringAlertsRequest& request) const;
 
  template <typename ListMonitoringAlertsRequestT = Model::ListMonitoringAlertsRequest>
  Model::ListMonitoringAlertsOutcomeCallable ListMonitoringAlertsCallable(const ListMonitoringAlertsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListMonitoringAlerts, request);
  }
 
  template <typename ListMonitoringAlertsRequestT = Model::ListMonitoringAlertsRequest>
  void ListMonitoringAlertsAsync(const ListMonitoringAlertsRequestT& request, const ListMonitoringAlertsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListMonitoringAlerts, request, handler, context);
  }
 
  virtual Model::ListMonitoringExecutionsOutcome ListMonitoringExecutions(const Model::ListMonitoringExecutionsRequest& request = {}) const;
 
  template <typename ListMonitoringExecutionsRequestT = Model::ListMonitoringExecutionsRequest>
  Model::ListMonitoringExecutionsOutcomeCallable ListMonitoringExecutionsCallable(
      const ListMonitoringExecutionsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListMonitoringExecutions, request);
  }
 
  template <typename ListMonitoringExecutionsRequestT = Model::ListMonitoringExecutionsRequest>
  void ListMonitoringExecutionsAsync(const ListMonitoringExecutionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListMonitoringExecutionsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListMonitoringExecutions, request, handler, context);
  }
 
  virtual Model::ListMonitoringSchedulesOutcome ListMonitoringSchedules(const Model::ListMonitoringSchedulesRequest& request = {}) const;
 
  template <typename ListMonitoringSchedulesRequestT = Model::ListMonitoringSchedulesRequest>
  Model::ListMonitoringSchedulesOutcomeCallable ListMonitoringSchedulesCallable(const ListMonitoringSchedulesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListMonitoringSchedules, request);
  }
 
  template <typename ListMonitoringSchedulesRequestT = Model::ListMonitoringSchedulesRequest>
  void ListMonitoringSchedulesAsync(const ListMonitoringSchedulesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListMonitoringSchedulesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListMonitoringSchedules, request, handler, context);
  }
 
  virtual Model::ListNotebookInstanceLifecycleConfigsOutcome ListNotebookInstanceLifecycleConfigs(
      const Model::ListNotebookInstanceLifecycleConfigsRequest& request = {}) const;
 
  template <typename ListNotebookInstanceLifecycleConfigsRequestT = Model::ListNotebookInstanceLifecycleConfigsRequest>
  Model::ListNotebookInstanceLifecycleConfigsOutcomeCallable ListNotebookInstanceLifecycleConfigsCallable(
      const ListNotebookInstanceLifecycleConfigsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListNotebookInstanceLifecycleConfigs, request);
  }
 
  template <typename ListNotebookInstanceLifecycleConfigsRequestT = Model::ListNotebookInstanceLifecycleConfigsRequest>
  void ListNotebookInstanceLifecycleConfigsAsync(const ListNotebookInstanceLifecycleConfigsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const ListNotebookInstanceLifecycleConfigsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListNotebookInstanceLifecycleConfigs, request, handler, context);
  }
 
  virtual Model::ListNotebookInstancesOutcome ListNotebookInstances(const Model::ListNotebookInstancesRequest& request = {}) const;
 
  template <typename ListNotebookInstancesRequestT = Model::ListNotebookInstancesRequest>
  Model::ListNotebookInstancesOutcomeCallable ListNotebookInstancesCallable(const ListNotebookInstancesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListNotebookInstances, request);
  }
 
  template <typename ListNotebookInstancesRequestT = Model::ListNotebookInstancesRequest>
  void ListNotebookInstancesAsync(const ListNotebookInstancesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListNotebookInstancesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListNotebookInstances, request, handler, context);
  }
 
  virtual Model::ListOptimizationJobsOutcome ListOptimizationJobs(const Model::ListOptimizationJobsRequest& request = {}) const;
 
  template <typename ListOptimizationJobsRequestT = Model::ListOptimizationJobsRequest>
  Model::ListOptimizationJobsOutcomeCallable ListOptimizationJobsCallable(const ListOptimizationJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListOptimizationJobs, request);
  }
 
  template <typename ListOptimizationJobsRequestT = Model::ListOptimizationJobsRequest>
  void ListOptimizationJobsAsync(const ListOptimizationJobsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListOptimizationJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListOptimizationJobs, request, handler, context);
  }
 
  virtual Model::ListPartnerAppsOutcome ListPartnerApps(const Model::ListPartnerAppsRequest& request = {}) const;
 
  template <typename ListPartnerAppsRequestT = Model::ListPartnerAppsRequest>
  Model::ListPartnerAppsOutcomeCallable ListPartnerAppsCallable(const ListPartnerAppsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListPartnerApps, request);
  }
 
  template <typename ListPartnerAppsRequestT = Model::ListPartnerAppsRequest>
  void ListPartnerAppsAsync(const ListPartnerAppsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListPartnerAppsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListPartnerApps, request, handler, context);
  }
 
  virtual Model::ListPipelineExecutionStepsOutcome ListPipelineExecutionSteps(
      const Model::ListPipelineExecutionStepsRequest& request = {}) const;
 
  template <typename ListPipelineExecutionStepsRequestT = Model::ListPipelineExecutionStepsRequest>
  Model::ListPipelineExecutionStepsOutcomeCallable ListPipelineExecutionStepsCallable(
      const ListPipelineExecutionStepsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListPipelineExecutionSteps, request);
  }
 
  template <typename ListPipelineExecutionStepsRequestT = Model::ListPipelineExecutionStepsRequest>
  void ListPipelineExecutionStepsAsync(const ListPipelineExecutionStepsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListPipelineExecutionStepsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListPipelineExecutionSteps, request, handler, context);
  }
 
  virtual Model::ListPipelineExecutionsOutcome ListPipelineExecutions(const Model::ListPipelineExecutionsRequest& request) const;
 
  template <typename ListPipelineExecutionsRequestT = Model::ListPipelineExecutionsRequest>
  Model::ListPipelineExecutionsOutcomeCallable ListPipelineExecutionsCallable(const ListPipelineExecutionsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListPipelineExecutions, request);
  }
 
  template <typename ListPipelineExecutionsRequestT = Model::ListPipelineExecutionsRequest>
  void ListPipelineExecutionsAsync(const ListPipelineExecutionsRequestT& request,
                                   const ListPipelineExecutionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListPipelineExecutions, request, handler, context);
  }
 
  virtual Model::ListPipelineParametersForExecutionOutcome ListPipelineParametersForExecution(
      const Model::ListPipelineParametersForExecutionRequest& request) const;
 
  template <typename ListPipelineParametersForExecutionRequestT = Model::ListPipelineParametersForExecutionRequest>
  Model::ListPipelineParametersForExecutionOutcomeCallable ListPipelineParametersForExecutionCallable(
      const ListPipelineParametersForExecutionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListPipelineParametersForExecution, request);
  }
 
  template <typename ListPipelineParametersForExecutionRequestT = Model::ListPipelineParametersForExecutionRequest>
  void ListPipelineParametersForExecutionAsync(const ListPipelineParametersForExecutionRequestT& request,
                                               const ListPipelineParametersForExecutionResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListPipelineParametersForExecution, request, handler, context);
  }
 
  virtual Model::ListPipelineVersionsOutcome ListPipelineVersions(const Model::ListPipelineVersionsRequest& request) const;
 
  template <typename ListPipelineVersionsRequestT = Model::ListPipelineVersionsRequest>
  Model::ListPipelineVersionsOutcomeCallable ListPipelineVersionsCallable(const ListPipelineVersionsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListPipelineVersions, request);
  }
 
  template <typename ListPipelineVersionsRequestT = Model::ListPipelineVersionsRequest>
  void ListPipelineVersionsAsync(const ListPipelineVersionsRequestT& request, const ListPipelineVersionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListPipelineVersions, request, handler, context);
  }
 
  virtual Model::ListPipelinesOutcome ListPipelines(const Model::ListPipelinesRequest& request = {}) const;
 
  template <typename ListPipelinesRequestT = Model::ListPipelinesRequest>
  Model::ListPipelinesOutcomeCallable ListPipelinesCallable(const ListPipelinesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListPipelines, request);
  }
 
  template <typename ListPipelinesRequestT = Model::ListPipelinesRequest>
  void ListPipelinesAsync(const ListPipelinesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListPipelinesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListPipelines, request, handler, context);
  }
 
  virtual Model::ListProcessingJobsOutcome ListProcessingJobs(const Model::ListProcessingJobsRequest& request = {}) const;
 
  template <typename ListProcessingJobsRequestT = Model::ListProcessingJobsRequest>
  Model::ListProcessingJobsOutcomeCallable ListProcessingJobsCallable(const ListProcessingJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListProcessingJobs, request);
  }
 
  template <typename ListProcessingJobsRequestT = Model::ListProcessingJobsRequest>
  void ListProcessingJobsAsync(const ListProcessingJobsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListProcessingJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListProcessingJobs, request, handler, context);
  }
 
  virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request = {}) const;
 
  template <typename ListProjectsRequestT = Model::ListProjectsRequest>
  Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListProjects, request);
  }
 
  template <typename ListProjectsRequestT = Model::ListProjectsRequest>
  void ListProjectsAsync(const ListProjectsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListProjectsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListProjects, request, handler, context);
  }
 
  virtual Model::ListResourceCatalogsOutcome ListResourceCatalogs(const Model::ListResourceCatalogsRequest& request = {}) const;
 
  template <typename ListResourceCatalogsRequestT = Model::ListResourceCatalogsRequest>
  Model::ListResourceCatalogsOutcomeCallable ListResourceCatalogsCallable(const ListResourceCatalogsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListResourceCatalogs, request);
  }
 
  template <typename ListResourceCatalogsRequestT = Model::ListResourceCatalogsRequest>
  void ListResourceCatalogsAsync(const ListResourceCatalogsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListResourceCatalogsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListResourceCatalogs, request, handler, context);
  }
 
  virtual Model::ListSpacesOutcome ListSpaces(const Model::ListSpacesRequest& request = {}) const;
 
  template <typename ListSpacesRequestT = Model::ListSpacesRequest>
  Model::ListSpacesOutcomeCallable ListSpacesCallable(const ListSpacesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListSpaces, request);
  }
 
  template <typename ListSpacesRequestT = Model::ListSpacesRequest>
  void ListSpacesAsync(const ListSpacesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListSpacesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListSpaces, request, handler, context);
  }
 
  virtual Model::ListStageDevicesOutcome ListStageDevices(const Model::ListStageDevicesRequest& request) const;
 
  template <typename ListStageDevicesRequestT = Model::ListStageDevicesRequest>
  Model::ListStageDevicesOutcomeCallable ListStageDevicesCallable(const ListStageDevicesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListStageDevices, request);
  }
 
  template <typename ListStageDevicesRequestT = Model::ListStageDevicesRequest>
  void ListStageDevicesAsync(const ListStageDevicesRequestT& request, const ListStageDevicesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListStageDevices, request, handler, context);
  }
 
  virtual Model::ListStudioLifecycleConfigsOutcome ListStudioLifecycleConfigs(
      const Model::ListStudioLifecycleConfigsRequest& request = {}) const;
 
  template <typename ListStudioLifecycleConfigsRequestT = Model::ListStudioLifecycleConfigsRequest>
  Model::ListStudioLifecycleConfigsOutcomeCallable ListStudioLifecycleConfigsCallable(
      const ListStudioLifecycleConfigsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListStudioLifecycleConfigs, request);
  }
 
  template <typename ListStudioLifecycleConfigsRequestT = Model::ListStudioLifecycleConfigsRequest>
  void ListStudioLifecycleConfigsAsync(const ListStudioLifecycleConfigsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListStudioLifecycleConfigsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListStudioLifecycleConfigs, request, handler, context);
  }
 
  virtual Model::ListSubscribedWorkteamsOutcome ListSubscribedWorkteams(const Model::ListSubscribedWorkteamsRequest& request = {}) const;
 
  template <typename ListSubscribedWorkteamsRequestT = Model::ListSubscribedWorkteamsRequest>
  Model::ListSubscribedWorkteamsOutcomeCallable ListSubscribedWorkteamsCallable(const ListSubscribedWorkteamsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListSubscribedWorkteams, request);
  }
 
  template <typename ListSubscribedWorkteamsRequestT = Model::ListSubscribedWorkteamsRequest>
  void ListSubscribedWorkteamsAsync(const ListSubscribedWorkteamsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListSubscribedWorkteamsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListSubscribedWorkteams, request, handler, context);
  }
 
  virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListTags, request);
  }
 
  template <typename ListTagsRequestT = Model::ListTagsRequest>
  void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListTags, request, handler, context);
  }
 
  virtual Model::ListTrainingJobsOutcome ListTrainingJobs(const Model::ListTrainingJobsRequest& request = {}) const;
 
  template <typename ListTrainingJobsRequestT = Model::ListTrainingJobsRequest>
  Model::ListTrainingJobsOutcomeCallable ListTrainingJobsCallable(const ListTrainingJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListTrainingJobs, request);
  }
 
  template <typename ListTrainingJobsRequestT = Model::ListTrainingJobsRequest>
  void ListTrainingJobsAsync(const ListTrainingJobsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListTrainingJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListTrainingJobs, request, handler, context);
  }
 
  virtual Model::ListTrainingJobsForHyperParameterTuningJobOutcome ListTrainingJobsForHyperParameterTuningJob(
      const Model::ListTrainingJobsForHyperParameterTuningJobRequest& request) const;
 
  template <typename ListTrainingJobsForHyperParameterTuningJobRequestT = Model::ListTrainingJobsForHyperParameterTuningJobRequest>
  Model::ListTrainingJobsForHyperParameterTuningJobOutcomeCallable ListTrainingJobsForHyperParameterTuningJobCallable(
      const ListTrainingJobsForHyperParameterTuningJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListTrainingJobsForHyperParameterTuningJob, request);
  }
 
  template <typename ListTrainingJobsForHyperParameterTuningJobRequestT = Model::ListTrainingJobsForHyperParameterTuningJobRequest>
  void ListTrainingJobsForHyperParameterTuningJobAsync(
      const ListTrainingJobsForHyperParameterTuningJobRequestT& request,
      const ListTrainingJobsForHyperParameterTuningJobResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListTrainingJobsForHyperParameterTuningJob, request, handler, context);
  }
 
  virtual Model::ListTrainingPlansOutcome ListTrainingPlans(const Model::ListTrainingPlansRequest& request = {}) const;
 
  template <typename ListTrainingPlansRequestT = Model::ListTrainingPlansRequest>
  Model::ListTrainingPlansOutcomeCallable ListTrainingPlansCallable(const ListTrainingPlansRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListTrainingPlans, request);
  }
 
  template <typename ListTrainingPlansRequestT = Model::ListTrainingPlansRequest>
  void ListTrainingPlansAsync(const ListTrainingPlansResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListTrainingPlansRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListTrainingPlans, request, handler, context);
  }
 
  virtual Model::ListTransformJobsOutcome ListTransformJobs(const Model::ListTransformJobsRequest& request = {}) const;
 
  template <typename ListTransformJobsRequestT = Model::ListTransformJobsRequest>
  Model::ListTransformJobsOutcomeCallable ListTransformJobsCallable(const ListTransformJobsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListTransformJobs, request);
  }
 
  template <typename ListTransformJobsRequestT = Model::ListTransformJobsRequest>
  void ListTransformJobsAsync(const ListTransformJobsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListTransformJobsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListTransformJobs, request, handler, context);
  }
 
  virtual Model::ListTrialComponentsOutcome ListTrialComponents(const Model::ListTrialComponentsRequest& request = {}) const;
 
  template <typename ListTrialComponentsRequestT = Model::ListTrialComponentsRequest>
  Model::ListTrialComponentsOutcomeCallable ListTrialComponentsCallable(const ListTrialComponentsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListTrialComponents, request);
  }
 
  template <typename ListTrialComponentsRequestT = Model::ListTrialComponentsRequest>
  void ListTrialComponentsAsync(const ListTrialComponentsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListTrialComponentsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListTrialComponents, request, handler, context);
  }
 
  virtual Model::ListTrialsOutcome ListTrials(const Model::ListTrialsRequest& request = {}) const;
 
  template <typename ListTrialsRequestT = Model::ListTrialsRequest>
  Model::ListTrialsOutcomeCallable ListTrialsCallable(const ListTrialsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListTrials, request);
  }
 
  template <typename ListTrialsRequestT = Model::ListTrialsRequest>
  void ListTrialsAsync(const ListTrialsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListTrialsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListTrials, request, handler, context);
  }
 
  virtual Model::ListUltraServersByReservedCapacityOutcome ListUltraServersByReservedCapacity(
      const Model::ListUltraServersByReservedCapacityRequest& request) const;
 
  template <typename ListUltraServersByReservedCapacityRequestT = Model::ListUltraServersByReservedCapacityRequest>
  Model::ListUltraServersByReservedCapacityOutcomeCallable ListUltraServersByReservedCapacityCallable(
      const ListUltraServersByReservedCapacityRequestT& request) const {
    return SubmitCallable(&SageMakerClient::ListUltraServersByReservedCapacity, request);
  }
 
  template <typename ListUltraServersByReservedCapacityRequestT = Model::ListUltraServersByReservedCapacityRequest>
  void ListUltraServersByReservedCapacityAsync(const ListUltraServersByReservedCapacityRequestT& request,
                                               const ListUltraServersByReservedCapacityResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::ListUltraServersByReservedCapacity, request, handler, context);
  }
 
  virtual Model::ListUserProfilesOutcome ListUserProfiles(const Model::ListUserProfilesRequest& request = {}) const;
 
  template <typename ListUserProfilesRequestT = Model::ListUserProfilesRequest>
  Model::ListUserProfilesOutcomeCallable ListUserProfilesCallable(const ListUserProfilesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListUserProfiles, request);
  }
 
  template <typename ListUserProfilesRequestT = Model::ListUserProfilesRequest>
  void ListUserProfilesAsync(const ListUserProfilesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListUserProfilesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListUserProfiles, request, handler, context);
  }
 
  virtual Model::ListWorkforcesOutcome ListWorkforces(const Model::ListWorkforcesRequest& request = {}) const;
 
  template <typename ListWorkforcesRequestT = Model::ListWorkforcesRequest>
  Model::ListWorkforcesOutcomeCallable ListWorkforcesCallable(const ListWorkforcesRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListWorkforces, request);
  }
 
  template <typename ListWorkforcesRequestT = Model::ListWorkforcesRequest>
  void ListWorkforcesAsync(const ListWorkforcesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListWorkforcesRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListWorkforces, request, handler, context);
  }
 
  virtual Model::ListWorkteamsOutcome ListWorkteams(const Model::ListWorkteamsRequest& request = {}) const;
 
  template <typename ListWorkteamsRequestT = Model::ListWorkteamsRequest>
  Model::ListWorkteamsOutcomeCallable ListWorkteamsCallable(const ListWorkteamsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::ListWorkteams, request);
  }
 
  template <typename ListWorkteamsRequestT = Model::ListWorkteamsRequest>
  void ListWorkteamsAsync(const ListWorkteamsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListWorkteamsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::ListWorkteams, request, handler, context);
  }
 
  virtual Model::PutModelPackageGroupPolicyOutcome PutModelPackageGroupPolicy(
      const Model::PutModelPackageGroupPolicyRequest& request) const;
 
  template <typename PutModelPackageGroupPolicyRequestT = Model::PutModelPackageGroupPolicyRequest>
  Model::PutModelPackageGroupPolicyOutcomeCallable PutModelPackageGroupPolicyCallable(
      const PutModelPackageGroupPolicyRequestT& request) const {
    return SubmitCallable(&SageMakerClient::PutModelPackageGroupPolicy, request);
  }
 
  template <typename PutModelPackageGroupPolicyRequestT = Model::PutModelPackageGroupPolicyRequest>
  void PutModelPackageGroupPolicyAsync(const PutModelPackageGroupPolicyRequestT& request,
                                       const PutModelPackageGroupPolicyResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::PutModelPackageGroupPolicy, request, handler, context);
  }
 
  virtual Model::QueryLineageOutcome QueryLineage(const Model::QueryLineageRequest& request = {}) const;
 
  template <typename QueryLineageRequestT = Model::QueryLineageRequest>
  Model::QueryLineageOutcomeCallable QueryLineageCallable(const QueryLineageRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::QueryLineage, request);
  }
 
  template <typename QueryLineageRequestT = Model::QueryLineageRequest>
  void QueryLineageAsync(const QueryLineageResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const QueryLineageRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::QueryLineage, request, handler, context);
  }
 
  virtual Model::RegisterDevicesOutcome RegisterDevices(const Model::RegisterDevicesRequest& request) const;
 
  template <typename RegisterDevicesRequestT = Model::RegisterDevicesRequest>
  Model::RegisterDevicesOutcomeCallable RegisterDevicesCallable(const RegisterDevicesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::RegisterDevices, request);
  }
 
  template <typename RegisterDevicesRequestT = Model::RegisterDevicesRequest>
  void RegisterDevicesAsync(const RegisterDevicesRequestT& request, const RegisterDevicesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::RegisterDevices, request, handler, context);
  }
 
  virtual Model::RenderUiTemplateOutcome RenderUiTemplate(const Model::RenderUiTemplateRequest& request) const;
 
  template <typename RenderUiTemplateRequestT = Model::RenderUiTemplateRequest>
  Model::RenderUiTemplateOutcomeCallable RenderUiTemplateCallable(const RenderUiTemplateRequestT& request) const {
    return SubmitCallable(&SageMakerClient::RenderUiTemplate, request);
  }
 
  template <typename RenderUiTemplateRequestT = Model::RenderUiTemplateRequest>
  void RenderUiTemplateAsync(const RenderUiTemplateRequestT& request, const RenderUiTemplateResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::RenderUiTemplate, request, handler, context);
  }
 
  virtual Model::RetryPipelineExecutionOutcome RetryPipelineExecution(const Model::RetryPipelineExecutionRequest& request) const;
 
  template <typename RetryPipelineExecutionRequestT = Model::RetryPipelineExecutionRequest>
  Model::RetryPipelineExecutionOutcomeCallable RetryPipelineExecutionCallable(const RetryPipelineExecutionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::RetryPipelineExecution, request);
  }
 
  template <typename RetryPipelineExecutionRequestT = Model::RetryPipelineExecutionRequest>
  void RetryPipelineExecutionAsync(const RetryPipelineExecutionRequestT& request,
                                   const RetryPipelineExecutionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::RetryPipelineExecution, request, handler, context);
  }
 
  virtual Model::SearchOutcome Search(const Model::SearchRequest& request) const;
 
  template <typename SearchRequestT = Model::SearchRequest>
  Model::SearchOutcomeCallable SearchCallable(const SearchRequestT& request) const {
    return SubmitCallable(&SageMakerClient::Search, request);
  }
 
  template <typename SearchRequestT = Model::SearchRequest>
  void SearchAsync(const SearchRequestT& request, const SearchResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::Search, request, handler, context);
  }
 
  virtual Model::SearchTrainingPlanOfferingsOutcome SearchTrainingPlanOfferings(
      const Model::SearchTrainingPlanOfferingsRequest& request = {}) const;
 
  template <typename SearchTrainingPlanOfferingsRequestT = Model::SearchTrainingPlanOfferingsRequest>
  Model::SearchTrainingPlanOfferingsOutcomeCallable SearchTrainingPlanOfferingsCallable(
      const SearchTrainingPlanOfferingsRequestT& request = {}) const {
    return SubmitCallable(&SageMakerClient::SearchTrainingPlanOfferings, request);
  }
 
  template <typename SearchTrainingPlanOfferingsRequestT = Model::SearchTrainingPlanOfferingsRequest>
  void SearchTrainingPlanOfferingsAsync(const SearchTrainingPlanOfferingsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const SearchTrainingPlanOfferingsRequestT& request = {}) const {
    return SubmitAsync(&SageMakerClient::SearchTrainingPlanOfferings, request, handler, context);
  }
 
  virtual Model::SendPipelineExecutionStepFailureOutcome SendPipelineExecutionStepFailure(
      const Model::SendPipelineExecutionStepFailureRequest& request) const;
 
  template <typename SendPipelineExecutionStepFailureRequestT = Model::SendPipelineExecutionStepFailureRequest>
  Model::SendPipelineExecutionStepFailureOutcomeCallable SendPipelineExecutionStepFailureCallable(
      const SendPipelineExecutionStepFailureRequestT& request) const {
    return SubmitCallable(&SageMakerClient::SendPipelineExecutionStepFailure, request);
  }
 
  template <typename SendPipelineExecutionStepFailureRequestT = Model::SendPipelineExecutionStepFailureRequest>
  void SendPipelineExecutionStepFailureAsync(const SendPipelineExecutionStepFailureRequestT& request,
                                             const SendPipelineExecutionStepFailureResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::SendPipelineExecutionStepFailure, request, handler, context);
  }
 
  virtual Model::SendPipelineExecutionStepSuccessOutcome SendPipelineExecutionStepSuccess(
      const Model::SendPipelineExecutionStepSuccessRequest& request) const;
 
  template <typename SendPipelineExecutionStepSuccessRequestT = Model::SendPipelineExecutionStepSuccessRequest>
  Model::SendPipelineExecutionStepSuccessOutcomeCallable SendPipelineExecutionStepSuccessCallable(
      const SendPipelineExecutionStepSuccessRequestT& request) const {
    return SubmitCallable(&SageMakerClient::SendPipelineExecutionStepSuccess, request);
  }
 
  template <typename SendPipelineExecutionStepSuccessRequestT = Model::SendPipelineExecutionStepSuccessRequest>
  void SendPipelineExecutionStepSuccessAsync(const SendPipelineExecutionStepSuccessRequestT& request,
                                             const SendPipelineExecutionStepSuccessResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::SendPipelineExecutionStepSuccess, request, handler, context);
  }
 
  virtual Model::StartEdgeDeploymentStageOutcome StartEdgeDeploymentStage(const Model::StartEdgeDeploymentStageRequest& request) const;
 
  template <typename StartEdgeDeploymentStageRequestT = Model::StartEdgeDeploymentStageRequest>
  Model::StartEdgeDeploymentStageOutcomeCallable StartEdgeDeploymentStageCallable(const StartEdgeDeploymentStageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StartEdgeDeploymentStage, request);
  }
 
  template <typename StartEdgeDeploymentStageRequestT = Model::StartEdgeDeploymentStageRequest>
  void StartEdgeDeploymentStageAsync(const StartEdgeDeploymentStageRequestT& request,
                                     const StartEdgeDeploymentStageResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StartEdgeDeploymentStage, request, handler, context);
  }
 
  virtual Model::StartInferenceExperimentOutcome StartInferenceExperiment(const Model::StartInferenceExperimentRequest& request) const;
 
  template <typename StartInferenceExperimentRequestT = Model::StartInferenceExperimentRequest>
  Model::StartInferenceExperimentOutcomeCallable StartInferenceExperimentCallable(const StartInferenceExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StartInferenceExperiment, request);
  }
 
  template <typename StartInferenceExperimentRequestT = Model::StartInferenceExperimentRequest>
  void StartInferenceExperimentAsync(const StartInferenceExperimentRequestT& request,
                                     const StartInferenceExperimentResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StartInferenceExperiment, request, handler, context);
  }
 
  virtual Model::StartMlflowTrackingServerOutcome StartMlflowTrackingServer(const Model::StartMlflowTrackingServerRequest& request) const;
 
  template <typename StartMlflowTrackingServerRequestT = Model::StartMlflowTrackingServerRequest>
  Model::StartMlflowTrackingServerOutcomeCallable StartMlflowTrackingServerCallable(
      const StartMlflowTrackingServerRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StartMlflowTrackingServer, request);
  }
 
  template <typename StartMlflowTrackingServerRequestT = Model::StartMlflowTrackingServerRequest>
  void StartMlflowTrackingServerAsync(const StartMlflowTrackingServerRequestT& request,
                                      const StartMlflowTrackingServerResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StartMlflowTrackingServer, request, handler, context);
  }
 
  virtual Model::StartMonitoringScheduleOutcome StartMonitoringSchedule(const Model::StartMonitoringScheduleRequest& request) const;
 
  template <typename StartMonitoringScheduleRequestT = Model::StartMonitoringScheduleRequest>
  Model::StartMonitoringScheduleOutcomeCallable StartMonitoringScheduleCallable(const StartMonitoringScheduleRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StartMonitoringSchedule, request);
  }
 
  template <typename StartMonitoringScheduleRequestT = Model::StartMonitoringScheduleRequest>
  void StartMonitoringScheduleAsync(const StartMonitoringScheduleRequestT& request,
                                    const StartMonitoringScheduleResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StartMonitoringSchedule, request, handler, context);
  }
 
  virtual Model::StartNotebookInstanceOutcome StartNotebookInstance(const Model::StartNotebookInstanceRequest& request) const;
 
  template <typename StartNotebookInstanceRequestT = Model::StartNotebookInstanceRequest>
  Model::StartNotebookInstanceOutcomeCallable StartNotebookInstanceCallable(const StartNotebookInstanceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StartNotebookInstance, request);
  }
 
  template <typename StartNotebookInstanceRequestT = Model::StartNotebookInstanceRequest>
  void StartNotebookInstanceAsync(const StartNotebookInstanceRequestT& request, const StartNotebookInstanceResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StartNotebookInstance, request, handler, context);
  }
 
  virtual Model::StartPipelineExecutionOutcome StartPipelineExecution(const Model::StartPipelineExecutionRequest& request) const;
 
  template <typename StartPipelineExecutionRequestT = Model::StartPipelineExecutionRequest>
  Model::StartPipelineExecutionOutcomeCallable StartPipelineExecutionCallable(const StartPipelineExecutionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StartPipelineExecution, request);
  }
 
  template <typename StartPipelineExecutionRequestT = Model::StartPipelineExecutionRequest>
  void StartPipelineExecutionAsync(const StartPipelineExecutionRequestT& request,
                                   const StartPipelineExecutionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StartPipelineExecution, request, handler, context);
  }
 
  virtual Model::StartSessionOutcome StartSession(const Model::StartSessionRequest& request) const;
 
  template <typename StartSessionRequestT = Model::StartSessionRequest>
  Model::StartSessionOutcomeCallable StartSessionCallable(const StartSessionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StartSession, request);
  }
 
  template <typename StartSessionRequestT = Model::StartSessionRequest>
  void StartSessionAsync(const StartSessionRequestT& request, const StartSessionResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StartSession, request, handler, context);
  }
 
  virtual Model::StopAutoMLJobOutcome StopAutoMLJob(const Model::StopAutoMLJobRequest& request) const;
 
  template <typename StopAutoMLJobRequestT = Model::StopAutoMLJobRequest>
  Model::StopAutoMLJobOutcomeCallable StopAutoMLJobCallable(const StopAutoMLJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopAutoMLJob, request);
  }
 
  template <typename StopAutoMLJobRequestT = Model::StopAutoMLJobRequest>
  void StopAutoMLJobAsync(const StopAutoMLJobRequestT& request, const StopAutoMLJobResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopAutoMLJob, request, handler, context);
  }
 
  virtual Model::StopCompilationJobOutcome StopCompilationJob(const Model::StopCompilationJobRequest& request) const;
 
  template <typename StopCompilationJobRequestT = Model::StopCompilationJobRequest>
  Model::StopCompilationJobOutcomeCallable StopCompilationJobCallable(const StopCompilationJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopCompilationJob, request);
  }
 
  template <typename StopCompilationJobRequestT = Model::StopCompilationJobRequest>
  void StopCompilationJobAsync(const StopCompilationJobRequestT& request, const StopCompilationJobResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopCompilationJob, request, handler, context);
  }
 
  virtual Model::StopEdgeDeploymentStageOutcome StopEdgeDeploymentStage(const Model::StopEdgeDeploymentStageRequest& request) const;
 
  template <typename StopEdgeDeploymentStageRequestT = Model::StopEdgeDeploymentStageRequest>
  Model::StopEdgeDeploymentStageOutcomeCallable StopEdgeDeploymentStageCallable(const StopEdgeDeploymentStageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopEdgeDeploymentStage, request);
  }
 
  template <typename StopEdgeDeploymentStageRequestT = Model::StopEdgeDeploymentStageRequest>
  void StopEdgeDeploymentStageAsync(const StopEdgeDeploymentStageRequestT& request,
                                    const StopEdgeDeploymentStageResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopEdgeDeploymentStage, request, handler, context);
  }
 
  virtual Model::StopEdgePackagingJobOutcome StopEdgePackagingJob(const Model::StopEdgePackagingJobRequest& request) const;
 
  template <typename StopEdgePackagingJobRequestT = Model::StopEdgePackagingJobRequest>
  Model::StopEdgePackagingJobOutcomeCallable StopEdgePackagingJobCallable(const StopEdgePackagingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopEdgePackagingJob, request);
  }
 
  template <typename StopEdgePackagingJobRequestT = Model::StopEdgePackagingJobRequest>
  void StopEdgePackagingJobAsync(const StopEdgePackagingJobRequestT& request, const StopEdgePackagingJobResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopEdgePackagingJob, request, handler, context);
  }
 
  virtual Model::StopHyperParameterTuningJobOutcome StopHyperParameterTuningJob(
      const Model::StopHyperParameterTuningJobRequest& request) const;
 
  template <typename StopHyperParameterTuningJobRequestT = Model::StopHyperParameterTuningJobRequest>
  Model::StopHyperParameterTuningJobOutcomeCallable StopHyperParameterTuningJobCallable(
      const StopHyperParameterTuningJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopHyperParameterTuningJob, request);
  }
 
  template <typename StopHyperParameterTuningJobRequestT = Model::StopHyperParameterTuningJobRequest>
  void StopHyperParameterTuningJobAsync(const StopHyperParameterTuningJobRequestT& request,
                                        const StopHyperParameterTuningJobResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopHyperParameterTuningJob, request, handler, context);
  }
 
  virtual Model::StopInferenceExperimentOutcome StopInferenceExperiment(const Model::StopInferenceExperimentRequest& request) const;
 
  template <typename StopInferenceExperimentRequestT = Model::StopInferenceExperimentRequest>
  Model::StopInferenceExperimentOutcomeCallable StopInferenceExperimentCallable(const StopInferenceExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopInferenceExperiment, request);
  }
 
  template <typename StopInferenceExperimentRequestT = Model::StopInferenceExperimentRequest>
  void StopInferenceExperimentAsync(const StopInferenceExperimentRequestT& request,
                                    const StopInferenceExperimentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopInferenceExperiment, request, handler, context);
  }
 
  virtual Model::StopInferenceRecommendationsJobOutcome StopInferenceRecommendationsJob(
      const Model::StopInferenceRecommendationsJobRequest& request) const;
 
  template <typename StopInferenceRecommendationsJobRequestT = Model::StopInferenceRecommendationsJobRequest>
  Model::StopInferenceRecommendationsJobOutcomeCallable StopInferenceRecommendationsJobCallable(
      const StopInferenceRecommendationsJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopInferenceRecommendationsJob, request);
  }
 
  template <typename StopInferenceRecommendationsJobRequestT = Model::StopInferenceRecommendationsJobRequest>
  void StopInferenceRecommendationsJobAsync(const StopInferenceRecommendationsJobRequestT& request,
                                            const StopInferenceRecommendationsJobResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopInferenceRecommendationsJob, request, handler, context);
  }
 
  virtual Model::StopLabelingJobOutcome StopLabelingJob(const Model::StopLabelingJobRequest& request) const;
 
  template <typename StopLabelingJobRequestT = Model::StopLabelingJobRequest>
  Model::StopLabelingJobOutcomeCallable StopLabelingJobCallable(const StopLabelingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopLabelingJob, request);
  }
 
  template <typename StopLabelingJobRequestT = Model::StopLabelingJobRequest>
  void StopLabelingJobAsync(const StopLabelingJobRequestT& request, const StopLabelingJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopLabelingJob, request, handler, context);
  }
 
  virtual Model::StopMlflowTrackingServerOutcome StopMlflowTrackingServer(const Model::StopMlflowTrackingServerRequest& request) const;
 
  template <typename StopMlflowTrackingServerRequestT = Model::StopMlflowTrackingServerRequest>
  Model::StopMlflowTrackingServerOutcomeCallable StopMlflowTrackingServerCallable(const StopMlflowTrackingServerRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopMlflowTrackingServer, request);
  }
 
  template <typename StopMlflowTrackingServerRequestT = Model::StopMlflowTrackingServerRequest>
  void StopMlflowTrackingServerAsync(const StopMlflowTrackingServerRequestT& request,
                                     const StopMlflowTrackingServerResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopMlflowTrackingServer, request, handler, context);
  }
 
  virtual Model::StopMonitoringScheduleOutcome StopMonitoringSchedule(const Model::StopMonitoringScheduleRequest& request) const;
 
  template <typename StopMonitoringScheduleRequestT = Model::StopMonitoringScheduleRequest>
  Model::StopMonitoringScheduleOutcomeCallable StopMonitoringScheduleCallable(const StopMonitoringScheduleRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopMonitoringSchedule, request);
  }
 
  template <typename StopMonitoringScheduleRequestT = Model::StopMonitoringScheduleRequest>
  void StopMonitoringScheduleAsync(const StopMonitoringScheduleRequestT& request,
                                   const StopMonitoringScheduleResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopMonitoringSchedule, request, handler, context);
  }
 
  virtual Model::StopNotebookInstanceOutcome StopNotebookInstance(const Model::StopNotebookInstanceRequest& request) const;
 
  template <typename StopNotebookInstanceRequestT = Model::StopNotebookInstanceRequest>
  Model::StopNotebookInstanceOutcomeCallable StopNotebookInstanceCallable(const StopNotebookInstanceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopNotebookInstance, request);
  }
 
  template <typename StopNotebookInstanceRequestT = Model::StopNotebookInstanceRequest>
  void StopNotebookInstanceAsync(const StopNotebookInstanceRequestT& request, const StopNotebookInstanceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopNotebookInstance, request, handler, context);
  }
 
  virtual Model::StopOptimizationJobOutcome StopOptimizationJob(const Model::StopOptimizationJobRequest& request) const;
 
  template <typename StopOptimizationJobRequestT = Model::StopOptimizationJobRequest>
  Model::StopOptimizationJobOutcomeCallable StopOptimizationJobCallable(const StopOptimizationJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopOptimizationJob, request);
  }
 
  template <typename StopOptimizationJobRequestT = Model::StopOptimizationJobRequest>
  void StopOptimizationJobAsync(const StopOptimizationJobRequestT& request, const StopOptimizationJobResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopOptimizationJob, request, handler, context);
  }
 
  virtual Model::StopPipelineExecutionOutcome StopPipelineExecution(const Model::StopPipelineExecutionRequest& request) const;
 
  template <typename StopPipelineExecutionRequestT = Model::StopPipelineExecutionRequest>
  Model::StopPipelineExecutionOutcomeCallable StopPipelineExecutionCallable(const StopPipelineExecutionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopPipelineExecution, request);
  }
 
  template <typename StopPipelineExecutionRequestT = Model::StopPipelineExecutionRequest>
  void StopPipelineExecutionAsync(const StopPipelineExecutionRequestT& request, const StopPipelineExecutionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopPipelineExecution, request, handler, context);
  }
 
  virtual Model::StopProcessingJobOutcome StopProcessingJob(const Model::StopProcessingJobRequest& request) const;
 
  template <typename StopProcessingJobRequestT = Model::StopProcessingJobRequest>
  Model::StopProcessingJobOutcomeCallable StopProcessingJobCallable(const StopProcessingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopProcessingJob, request);
  }
 
  template <typename StopProcessingJobRequestT = Model::StopProcessingJobRequest>
  void StopProcessingJobAsync(const StopProcessingJobRequestT& request, const StopProcessingJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopProcessingJob, request, handler, context);
  }
 
  virtual Model::StopTrainingJobOutcome StopTrainingJob(const Model::StopTrainingJobRequest& request) const;
 
  template <typename StopTrainingJobRequestT = Model::StopTrainingJobRequest>
  Model::StopTrainingJobOutcomeCallable StopTrainingJobCallable(const StopTrainingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopTrainingJob, request);
  }
 
  template <typename StopTrainingJobRequestT = Model::StopTrainingJobRequest>
  void StopTrainingJobAsync(const StopTrainingJobRequestT& request, const StopTrainingJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopTrainingJob, request, handler, context);
  }
 
  virtual Model::StopTransformJobOutcome StopTransformJob(const Model::StopTransformJobRequest& request) const;
 
  template <typename StopTransformJobRequestT = Model::StopTransformJobRequest>
  Model::StopTransformJobOutcomeCallable StopTransformJobCallable(const StopTransformJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::StopTransformJob, request);
  }
 
  template <typename StopTransformJobRequestT = Model::StopTransformJobRequest>
  void StopTransformJobAsync(const StopTransformJobRequestT& request, const StopTransformJobResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::StopTransformJob, request, handler, context);
  }
 
  virtual Model::UpdateActionOutcome UpdateAction(const Model::UpdateActionRequest& request) const;
 
  template <typename UpdateActionRequestT = Model::UpdateActionRequest>
  Model::UpdateActionOutcomeCallable UpdateActionCallable(const UpdateActionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateAction, request);
  }
 
  template <typename UpdateActionRequestT = Model::UpdateActionRequest>
  void UpdateActionAsync(const UpdateActionRequestT& request, const UpdateActionResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateAction, request, handler, context);
  }
 
  virtual Model::UpdateAppImageConfigOutcome UpdateAppImageConfig(const Model::UpdateAppImageConfigRequest& request) const;
 
  template <typename UpdateAppImageConfigRequestT = Model::UpdateAppImageConfigRequest>
  Model::UpdateAppImageConfigOutcomeCallable UpdateAppImageConfigCallable(const UpdateAppImageConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateAppImageConfig, request);
  }
 
  template <typename UpdateAppImageConfigRequestT = Model::UpdateAppImageConfigRequest>
  void UpdateAppImageConfigAsync(const UpdateAppImageConfigRequestT& request, const UpdateAppImageConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateAppImageConfig, request, handler, context);
  }
 
  virtual Model::UpdateArtifactOutcome UpdateArtifact(const Model::UpdateArtifactRequest& request) const;
 
  template <typename UpdateArtifactRequestT = Model::UpdateArtifactRequest>
  Model::UpdateArtifactOutcomeCallable UpdateArtifactCallable(const UpdateArtifactRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateArtifact, request);
  }
 
  template <typename UpdateArtifactRequestT = Model::UpdateArtifactRequest>
  void UpdateArtifactAsync(const UpdateArtifactRequestT& request, const UpdateArtifactResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateArtifact, request, handler, context);
  }
 
  virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const;
 
  template <typename UpdateClusterRequestT = Model::UpdateClusterRequest>
  Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const UpdateClusterRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateCluster, request);
  }
 
  template <typename UpdateClusterRequestT = Model::UpdateClusterRequest>
  void UpdateClusterAsync(const UpdateClusterRequestT& request, const UpdateClusterResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateCluster, request, handler, context);
  }
 
  virtual Model::UpdateClusterSchedulerConfigOutcome UpdateClusterSchedulerConfig(
      const Model::UpdateClusterSchedulerConfigRequest& request) const;
 
  template <typename UpdateClusterSchedulerConfigRequestT = Model::UpdateClusterSchedulerConfigRequest>
  Model::UpdateClusterSchedulerConfigOutcomeCallable UpdateClusterSchedulerConfigCallable(
      const UpdateClusterSchedulerConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateClusterSchedulerConfig, request);
  }
 
  template <typename UpdateClusterSchedulerConfigRequestT = Model::UpdateClusterSchedulerConfigRequest>
  void UpdateClusterSchedulerConfigAsync(const UpdateClusterSchedulerConfigRequestT& request,
                                         const UpdateClusterSchedulerConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateClusterSchedulerConfig, request, handler, context);
  }
 
  virtual Model::UpdateClusterSoftwareOutcome UpdateClusterSoftware(const Model::UpdateClusterSoftwareRequest& request) const;
 
  template <typename UpdateClusterSoftwareRequestT = Model::UpdateClusterSoftwareRequest>
  Model::UpdateClusterSoftwareOutcomeCallable UpdateClusterSoftwareCallable(const UpdateClusterSoftwareRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateClusterSoftware, request);
  }
 
  template <typename UpdateClusterSoftwareRequestT = Model::UpdateClusterSoftwareRequest>
  void UpdateClusterSoftwareAsync(const UpdateClusterSoftwareRequestT& request, const UpdateClusterSoftwareResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateClusterSoftware, request, handler, context);
  }
 
  virtual Model::UpdateCodeRepositoryOutcome UpdateCodeRepository(const Model::UpdateCodeRepositoryRequest& request) const;
 
  template <typename UpdateCodeRepositoryRequestT = Model::UpdateCodeRepositoryRequest>
  Model::UpdateCodeRepositoryOutcomeCallable UpdateCodeRepositoryCallable(const UpdateCodeRepositoryRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateCodeRepository, request);
  }
 
  template <typename UpdateCodeRepositoryRequestT = Model::UpdateCodeRepositoryRequest>
  void UpdateCodeRepositoryAsync(const UpdateCodeRepositoryRequestT& request, const UpdateCodeRepositoryResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateCodeRepository, request, handler, context);
  }
 
  virtual Model::UpdateComputeQuotaOutcome UpdateComputeQuota(const Model::UpdateComputeQuotaRequest& request) const;
 
  template <typename UpdateComputeQuotaRequestT = Model::UpdateComputeQuotaRequest>
  Model::UpdateComputeQuotaOutcomeCallable UpdateComputeQuotaCallable(const UpdateComputeQuotaRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateComputeQuota, request);
  }
 
  template <typename UpdateComputeQuotaRequestT = Model::UpdateComputeQuotaRequest>
  void UpdateComputeQuotaAsync(const UpdateComputeQuotaRequestT& request, const UpdateComputeQuotaResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateComputeQuota, request, handler, context);
  }
 
  virtual Model::UpdateContextOutcome UpdateContext(const Model::UpdateContextRequest& request) const;
 
  template <typename UpdateContextRequestT = Model::UpdateContextRequest>
  Model::UpdateContextOutcomeCallable UpdateContextCallable(const UpdateContextRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateContext, request);
  }
 
  template <typename UpdateContextRequestT = Model::UpdateContextRequest>
  void UpdateContextAsync(const UpdateContextRequestT& request, const UpdateContextResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateContext, request, handler, context);
  }
 
  virtual Model::UpdateDeviceFleetOutcome UpdateDeviceFleet(const Model::UpdateDeviceFleetRequest& request) const;
 
  template <typename UpdateDeviceFleetRequestT = Model::UpdateDeviceFleetRequest>
  Model::UpdateDeviceFleetOutcomeCallable UpdateDeviceFleetCallable(const UpdateDeviceFleetRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateDeviceFleet, request);
  }
 
  template <typename UpdateDeviceFleetRequestT = Model::UpdateDeviceFleetRequest>
  void UpdateDeviceFleetAsync(const UpdateDeviceFleetRequestT& request, const UpdateDeviceFleetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateDeviceFleet, request, handler, context);
  }
 
  virtual Model::UpdateDevicesOutcome UpdateDevices(const Model::UpdateDevicesRequest& request) const;
 
  template <typename UpdateDevicesRequestT = Model::UpdateDevicesRequest>
  Model::UpdateDevicesOutcomeCallable UpdateDevicesCallable(const UpdateDevicesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateDevices, request);
  }
 
  template <typename UpdateDevicesRequestT = Model::UpdateDevicesRequest>
  void UpdateDevicesAsync(const UpdateDevicesRequestT& request, const UpdateDevicesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateDevices, request, handler, context);
  }
 
  virtual Model::UpdateDomainOutcome UpdateDomain(const Model::UpdateDomainRequest& request) const;
 
  template <typename UpdateDomainRequestT = Model::UpdateDomainRequest>
  Model::UpdateDomainOutcomeCallable UpdateDomainCallable(const UpdateDomainRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateDomain, request);
  }
 
  template <typename UpdateDomainRequestT = Model::UpdateDomainRequest>
  void UpdateDomainAsync(const UpdateDomainRequestT& request, const UpdateDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateDomain, request, handler, context);
  }
 
  virtual Model::UpdateEndpointOutcome UpdateEndpoint(const Model::UpdateEndpointRequest& request) const;
 
  template <typename UpdateEndpointRequestT = Model::UpdateEndpointRequest>
  Model::UpdateEndpointOutcomeCallable UpdateEndpointCallable(const UpdateEndpointRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateEndpoint, request);
  }
 
  template <typename UpdateEndpointRequestT = Model::UpdateEndpointRequest>
  void UpdateEndpointAsync(const UpdateEndpointRequestT& request, const UpdateEndpointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateEndpoint, request, handler, context);
  }
 
  virtual Model::UpdateEndpointWeightsAndCapacitiesOutcome UpdateEndpointWeightsAndCapacities(
      const Model::UpdateEndpointWeightsAndCapacitiesRequest& request) const;
 
  template <typename UpdateEndpointWeightsAndCapacitiesRequestT = Model::UpdateEndpointWeightsAndCapacitiesRequest>
  Model::UpdateEndpointWeightsAndCapacitiesOutcomeCallable UpdateEndpointWeightsAndCapacitiesCallable(
      const UpdateEndpointWeightsAndCapacitiesRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateEndpointWeightsAndCapacities, request);
  }
 
  template <typename UpdateEndpointWeightsAndCapacitiesRequestT = Model::UpdateEndpointWeightsAndCapacitiesRequest>
  void UpdateEndpointWeightsAndCapacitiesAsync(const UpdateEndpointWeightsAndCapacitiesRequestT& request,
                                               const UpdateEndpointWeightsAndCapacitiesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateEndpointWeightsAndCapacities, request, handler, context);
  }
 
  virtual Model::UpdateExperimentOutcome UpdateExperiment(const Model::UpdateExperimentRequest& request) const;
 
  template <typename UpdateExperimentRequestT = Model::UpdateExperimentRequest>
  Model::UpdateExperimentOutcomeCallable UpdateExperimentCallable(const UpdateExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateExperiment, request);
  }
 
  template <typename UpdateExperimentRequestT = Model::UpdateExperimentRequest>
  void UpdateExperimentAsync(const UpdateExperimentRequestT& request, const UpdateExperimentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateExperiment, request, handler, context);
  }
 
  virtual Model::UpdateFeatureGroupOutcome UpdateFeatureGroup(const Model::UpdateFeatureGroupRequest& request) const;
 
  template <typename UpdateFeatureGroupRequestT = Model::UpdateFeatureGroupRequest>
  Model::UpdateFeatureGroupOutcomeCallable UpdateFeatureGroupCallable(const UpdateFeatureGroupRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateFeatureGroup, request);
  }
 
  template <typename UpdateFeatureGroupRequestT = Model::UpdateFeatureGroupRequest>
  void UpdateFeatureGroupAsync(const UpdateFeatureGroupRequestT& request, const UpdateFeatureGroupResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateFeatureGroup, request, handler, context);
  }
 
  virtual Model::UpdateFeatureMetadataOutcome UpdateFeatureMetadata(const Model::UpdateFeatureMetadataRequest& request) const;
 
  template <typename UpdateFeatureMetadataRequestT = Model::UpdateFeatureMetadataRequest>
  Model::UpdateFeatureMetadataOutcomeCallable UpdateFeatureMetadataCallable(const UpdateFeatureMetadataRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateFeatureMetadata, request);
  }
 
  template <typename UpdateFeatureMetadataRequestT = Model::UpdateFeatureMetadataRequest>
  void UpdateFeatureMetadataAsync(const UpdateFeatureMetadataRequestT& request, const UpdateFeatureMetadataResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateFeatureMetadata, request, handler, context);
  }
 
  virtual Model::UpdateHubOutcome UpdateHub(const Model::UpdateHubRequest& request) const;
 
  template <typename UpdateHubRequestT = Model::UpdateHubRequest>
  Model::UpdateHubOutcomeCallable UpdateHubCallable(const UpdateHubRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateHub, request);
  }
 
  template <typename UpdateHubRequestT = Model::UpdateHubRequest>
  void UpdateHubAsync(const UpdateHubRequestT& request, const UpdateHubResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateHub, request, handler, context);
  }
 
  virtual Model::UpdateHubContentOutcome UpdateHubContent(const Model::UpdateHubContentRequest& request) const;
 
  template <typename UpdateHubContentRequestT = Model::UpdateHubContentRequest>
  Model::UpdateHubContentOutcomeCallable UpdateHubContentCallable(const UpdateHubContentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateHubContent, request);
  }
 
  template <typename UpdateHubContentRequestT = Model::UpdateHubContentRequest>
  void UpdateHubContentAsync(const UpdateHubContentRequestT& request, const UpdateHubContentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateHubContent, request, handler, context);
  }
 
  virtual Model::UpdateHubContentReferenceOutcome UpdateHubContentReference(const Model::UpdateHubContentReferenceRequest& request) const;
 
  template <typename UpdateHubContentReferenceRequestT = Model::UpdateHubContentReferenceRequest>
  Model::UpdateHubContentReferenceOutcomeCallable UpdateHubContentReferenceCallable(
      const UpdateHubContentReferenceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateHubContentReference, request);
  }
 
  template <typename UpdateHubContentReferenceRequestT = Model::UpdateHubContentReferenceRequest>
  void UpdateHubContentReferenceAsync(const UpdateHubContentReferenceRequestT& request,
                                      const UpdateHubContentReferenceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateHubContentReference, request, handler, context);
  }
 
  virtual Model::UpdateImageOutcome UpdateImage(const Model::UpdateImageRequest& request) const;
 
  template <typename UpdateImageRequestT = Model::UpdateImageRequest>
  Model::UpdateImageOutcomeCallable UpdateImageCallable(const UpdateImageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateImage, request);
  }
 
  template <typename UpdateImageRequestT = Model::UpdateImageRequest>
  void UpdateImageAsync(const UpdateImageRequestT& request, const UpdateImageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateImage, request, handler, context);
  }
 
  virtual Model::UpdateImageVersionOutcome UpdateImageVersion(const Model::UpdateImageVersionRequest& request) const;
 
  template <typename UpdateImageVersionRequestT = Model::UpdateImageVersionRequest>
  Model::UpdateImageVersionOutcomeCallable UpdateImageVersionCallable(const UpdateImageVersionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateImageVersion, request);
  }
 
  template <typename UpdateImageVersionRequestT = Model::UpdateImageVersionRequest>
  void UpdateImageVersionAsync(const UpdateImageVersionRequestT& request, const UpdateImageVersionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateImageVersion, request, handler, context);
  }
 
  virtual Model::UpdateInferenceComponentOutcome UpdateInferenceComponent(const Model::UpdateInferenceComponentRequest& request) const;
 
  template <typename UpdateInferenceComponentRequestT = Model::UpdateInferenceComponentRequest>
  Model::UpdateInferenceComponentOutcomeCallable UpdateInferenceComponentCallable(const UpdateInferenceComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateInferenceComponent, request);
  }
 
  template <typename UpdateInferenceComponentRequestT = Model::UpdateInferenceComponentRequest>
  void UpdateInferenceComponentAsync(const UpdateInferenceComponentRequestT& request,
                                     const UpdateInferenceComponentResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateInferenceComponent, request, handler, context);
  }
 
  virtual Model::UpdateInferenceComponentRuntimeConfigOutcome UpdateInferenceComponentRuntimeConfig(
      const Model::UpdateInferenceComponentRuntimeConfigRequest& request) const;
 
  template <typename UpdateInferenceComponentRuntimeConfigRequestT = Model::UpdateInferenceComponentRuntimeConfigRequest>
  Model::UpdateInferenceComponentRuntimeConfigOutcomeCallable UpdateInferenceComponentRuntimeConfigCallable(
      const UpdateInferenceComponentRuntimeConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateInferenceComponentRuntimeConfig, request);
  }
 
  template <typename UpdateInferenceComponentRuntimeConfigRequestT = Model::UpdateInferenceComponentRuntimeConfigRequest>
  void UpdateInferenceComponentRuntimeConfigAsync(const UpdateInferenceComponentRuntimeConfigRequestT& request,
                                                  const UpdateInferenceComponentRuntimeConfigResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateInferenceComponentRuntimeConfig, request, handler, context);
  }
 
  virtual Model::UpdateInferenceExperimentOutcome UpdateInferenceExperiment(const Model::UpdateInferenceExperimentRequest& request) const;
 
  template <typename UpdateInferenceExperimentRequestT = Model::UpdateInferenceExperimentRequest>
  Model::UpdateInferenceExperimentOutcomeCallable UpdateInferenceExperimentCallable(
      const UpdateInferenceExperimentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateInferenceExperiment, request);
  }
 
  template <typename UpdateInferenceExperimentRequestT = Model::UpdateInferenceExperimentRequest>
  void UpdateInferenceExperimentAsync(const UpdateInferenceExperimentRequestT& request,
                                      const UpdateInferenceExperimentResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateInferenceExperiment, request, handler, context);
  }
 
  virtual Model::UpdateMlflowAppOutcome UpdateMlflowApp(const Model::UpdateMlflowAppRequest& request) const;
 
  template <typename UpdateMlflowAppRequestT = Model::UpdateMlflowAppRequest>
  Model::UpdateMlflowAppOutcomeCallable UpdateMlflowAppCallable(const UpdateMlflowAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateMlflowApp, request);
  }
 
  template <typename UpdateMlflowAppRequestT = Model::UpdateMlflowAppRequest>
  void UpdateMlflowAppAsync(const UpdateMlflowAppRequestT& request, const UpdateMlflowAppResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateMlflowApp, request, handler, context);
  }
 
  virtual Model::UpdateMlflowTrackingServerOutcome UpdateMlflowTrackingServer(
      const Model::UpdateMlflowTrackingServerRequest& request) const;
 
  template <typename UpdateMlflowTrackingServerRequestT = Model::UpdateMlflowTrackingServerRequest>
  Model::UpdateMlflowTrackingServerOutcomeCallable UpdateMlflowTrackingServerCallable(
      const UpdateMlflowTrackingServerRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateMlflowTrackingServer, request);
  }
 
  template <typename UpdateMlflowTrackingServerRequestT = Model::UpdateMlflowTrackingServerRequest>
  void UpdateMlflowTrackingServerAsync(const UpdateMlflowTrackingServerRequestT& request,
                                       const UpdateMlflowTrackingServerResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateMlflowTrackingServer, request, handler, context);
  }
 
  virtual Model::UpdateModelCardOutcome UpdateModelCard(const Model::UpdateModelCardRequest& request) const;
 
  template <typename UpdateModelCardRequestT = Model::UpdateModelCardRequest>
  Model::UpdateModelCardOutcomeCallable UpdateModelCardCallable(const UpdateModelCardRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateModelCard, request);
  }
 
  template <typename UpdateModelCardRequestT = Model::UpdateModelCardRequest>
  void UpdateModelCardAsync(const UpdateModelCardRequestT& request, const UpdateModelCardResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateModelCard, request, handler, context);
  }
 
  virtual Model::UpdateModelPackageOutcome UpdateModelPackage(const Model::UpdateModelPackageRequest& request) const;
 
  template <typename UpdateModelPackageRequestT = Model::UpdateModelPackageRequest>
  Model::UpdateModelPackageOutcomeCallable UpdateModelPackageCallable(const UpdateModelPackageRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateModelPackage, request);
  }
 
  template <typename UpdateModelPackageRequestT = Model::UpdateModelPackageRequest>
  void UpdateModelPackageAsync(const UpdateModelPackageRequestT& request, const UpdateModelPackageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateModelPackage, request, handler, context);
  }
 
  virtual Model::UpdateMonitoringAlertOutcome UpdateMonitoringAlert(const Model::UpdateMonitoringAlertRequest& request) const;
 
  template <typename UpdateMonitoringAlertRequestT = Model::UpdateMonitoringAlertRequest>
  Model::UpdateMonitoringAlertOutcomeCallable UpdateMonitoringAlertCallable(const UpdateMonitoringAlertRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateMonitoringAlert, request);
  }
 
  template <typename UpdateMonitoringAlertRequestT = Model::UpdateMonitoringAlertRequest>
  void UpdateMonitoringAlertAsync(const UpdateMonitoringAlertRequestT& request, const UpdateMonitoringAlertResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateMonitoringAlert, request, handler, context);
  }
 
  virtual Model::UpdateMonitoringScheduleOutcome UpdateMonitoringSchedule(const Model::UpdateMonitoringScheduleRequest& request) const;
 
  template <typename UpdateMonitoringScheduleRequestT = Model::UpdateMonitoringScheduleRequest>
  Model::UpdateMonitoringScheduleOutcomeCallable UpdateMonitoringScheduleCallable(const UpdateMonitoringScheduleRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateMonitoringSchedule, request);
  }
 
  template <typename UpdateMonitoringScheduleRequestT = Model::UpdateMonitoringScheduleRequest>
  void UpdateMonitoringScheduleAsync(const UpdateMonitoringScheduleRequestT& request,
                                     const UpdateMonitoringScheduleResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateMonitoringSchedule, request, handler, context);
  }
 
  virtual Model::UpdateNotebookInstanceOutcome UpdateNotebookInstance(const Model::UpdateNotebookInstanceRequest& request) const;
 
  template <typename UpdateNotebookInstanceRequestT = Model::UpdateNotebookInstanceRequest>
  Model::UpdateNotebookInstanceOutcomeCallable UpdateNotebookInstanceCallable(const UpdateNotebookInstanceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateNotebookInstance, request);
  }
 
  template <typename UpdateNotebookInstanceRequestT = Model::UpdateNotebookInstanceRequest>
  void UpdateNotebookInstanceAsync(const UpdateNotebookInstanceRequestT& request,
                                   const UpdateNotebookInstanceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateNotebookInstance, request, handler, context);
  }
 
  virtual Model::UpdateNotebookInstanceLifecycleConfigOutcome UpdateNotebookInstanceLifecycleConfig(
      const Model::UpdateNotebookInstanceLifecycleConfigRequest& request) const;
 
  template <typename UpdateNotebookInstanceLifecycleConfigRequestT = Model::UpdateNotebookInstanceLifecycleConfigRequest>
  Model::UpdateNotebookInstanceLifecycleConfigOutcomeCallable UpdateNotebookInstanceLifecycleConfigCallable(
      const UpdateNotebookInstanceLifecycleConfigRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateNotebookInstanceLifecycleConfig, request);
  }
 
  template <typename UpdateNotebookInstanceLifecycleConfigRequestT = Model::UpdateNotebookInstanceLifecycleConfigRequest>
  void UpdateNotebookInstanceLifecycleConfigAsync(const UpdateNotebookInstanceLifecycleConfigRequestT& request,
                                                  const UpdateNotebookInstanceLifecycleConfigResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateNotebookInstanceLifecycleConfig, request, handler, context);
  }
 
  virtual Model::UpdatePartnerAppOutcome UpdatePartnerApp(const Model::UpdatePartnerAppRequest& request) const;
 
  template <typename UpdatePartnerAppRequestT = Model::UpdatePartnerAppRequest>
  Model::UpdatePartnerAppOutcomeCallable UpdatePartnerAppCallable(const UpdatePartnerAppRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdatePartnerApp, request);
  }
 
  template <typename UpdatePartnerAppRequestT = Model::UpdatePartnerAppRequest>
  void UpdatePartnerAppAsync(const UpdatePartnerAppRequestT& request, const UpdatePartnerAppResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdatePartnerApp, request, handler, context);
  }
 
  virtual Model::UpdatePipelineOutcome UpdatePipeline(const Model::UpdatePipelineRequest& request) const;
 
  template <typename UpdatePipelineRequestT = Model::UpdatePipelineRequest>
  Model::UpdatePipelineOutcomeCallable UpdatePipelineCallable(const UpdatePipelineRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdatePipeline, request);
  }
 
  template <typename UpdatePipelineRequestT = Model::UpdatePipelineRequest>
  void UpdatePipelineAsync(const UpdatePipelineRequestT& request, const UpdatePipelineResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdatePipeline, request, handler, context);
  }
 
  virtual Model::UpdatePipelineExecutionOutcome UpdatePipelineExecution(const Model::UpdatePipelineExecutionRequest& request) const;
 
  template <typename UpdatePipelineExecutionRequestT = Model::UpdatePipelineExecutionRequest>
  Model::UpdatePipelineExecutionOutcomeCallable UpdatePipelineExecutionCallable(const UpdatePipelineExecutionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdatePipelineExecution, request);
  }
 
  template <typename UpdatePipelineExecutionRequestT = Model::UpdatePipelineExecutionRequest>
  void UpdatePipelineExecutionAsync(const UpdatePipelineExecutionRequestT& request,
                                    const UpdatePipelineExecutionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdatePipelineExecution, request, handler, context);
  }
 
  virtual Model::UpdatePipelineVersionOutcome UpdatePipelineVersion(const Model::UpdatePipelineVersionRequest& request) const;
 
  template <typename UpdatePipelineVersionRequestT = Model::UpdatePipelineVersionRequest>
  Model::UpdatePipelineVersionOutcomeCallable UpdatePipelineVersionCallable(const UpdatePipelineVersionRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdatePipelineVersion, request);
  }
 
  template <typename UpdatePipelineVersionRequestT = Model::UpdatePipelineVersionRequest>
  void UpdatePipelineVersionAsync(const UpdatePipelineVersionRequestT& request, const UpdatePipelineVersionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdatePipelineVersion, request, handler, context);
  }
 
  virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const;
 
  template <typename UpdateProjectRequestT = Model::UpdateProjectRequest>
  Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateProject, request);
  }
 
  template <typename UpdateProjectRequestT = Model::UpdateProjectRequest>
  void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateProject, request, handler, context);
  }
 
  virtual Model::UpdateSpaceOutcome UpdateSpace(const Model::UpdateSpaceRequest& request) const;
 
  template <typename UpdateSpaceRequestT = Model::UpdateSpaceRequest>
  Model::UpdateSpaceOutcomeCallable UpdateSpaceCallable(const UpdateSpaceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateSpace, request);
  }
 
  template <typename UpdateSpaceRequestT = Model::UpdateSpaceRequest>
  void UpdateSpaceAsync(const UpdateSpaceRequestT& request, const UpdateSpaceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateSpace, request, handler, context);
  }
 
  virtual Model::UpdateTrainingJobOutcome UpdateTrainingJob(const Model::UpdateTrainingJobRequest& request) const;
 
  template <typename UpdateTrainingJobRequestT = Model::UpdateTrainingJobRequest>
  Model::UpdateTrainingJobOutcomeCallable UpdateTrainingJobCallable(const UpdateTrainingJobRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateTrainingJob, request);
  }
 
  template <typename UpdateTrainingJobRequestT = Model::UpdateTrainingJobRequest>
  void UpdateTrainingJobAsync(const UpdateTrainingJobRequestT& request, const UpdateTrainingJobResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateTrainingJob, request, handler, context);
  }
 
  virtual Model::UpdateTrialOutcome UpdateTrial(const Model::UpdateTrialRequest& request) const;
 
  template <typename UpdateTrialRequestT = Model::UpdateTrialRequest>
  Model::UpdateTrialOutcomeCallable UpdateTrialCallable(const UpdateTrialRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateTrial, request);
  }
 
  template <typename UpdateTrialRequestT = Model::UpdateTrialRequest>
  void UpdateTrialAsync(const UpdateTrialRequestT& request, const UpdateTrialResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateTrial, request, handler, context);
  }
 
  virtual Model::UpdateTrialComponentOutcome UpdateTrialComponent(const Model::UpdateTrialComponentRequest& request) const;
 
  template <typename UpdateTrialComponentRequestT = Model::UpdateTrialComponentRequest>
  Model::UpdateTrialComponentOutcomeCallable UpdateTrialComponentCallable(const UpdateTrialComponentRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateTrialComponent, request);
  }
 
  template <typename UpdateTrialComponentRequestT = Model::UpdateTrialComponentRequest>
  void UpdateTrialComponentAsync(const UpdateTrialComponentRequestT& request, const UpdateTrialComponentResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateTrialComponent, request, handler, context);
  }
 
  virtual Model::UpdateUserProfileOutcome UpdateUserProfile(const Model::UpdateUserProfileRequest& request) const;
 
  template <typename UpdateUserProfileRequestT = Model::UpdateUserProfileRequest>
  Model::UpdateUserProfileOutcomeCallable UpdateUserProfileCallable(const UpdateUserProfileRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateUserProfile, request);
  }
 
  template <typename UpdateUserProfileRequestT = Model::UpdateUserProfileRequest>
  void UpdateUserProfileAsync(const UpdateUserProfileRequestT& request, const UpdateUserProfileResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateUserProfile, request, handler, context);
  }
 
  virtual Model::UpdateWorkforceOutcome UpdateWorkforce(const Model::UpdateWorkforceRequest& request) const;
 
  template <typename UpdateWorkforceRequestT = Model::UpdateWorkforceRequest>
  Model::UpdateWorkforceOutcomeCallable UpdateWorkforceCallable(const UpdateWorkforceRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateWorkforce, request);
  }
 
  template <typename UpdateWorkforceRequestT = Model::UpdateWorkforceRequest>
  void UpdateWorkforceAsync(const UpdateWorkforceRequestT& request, const UpdateWorkforceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateWorkforce, request, handler, context);
  }
 
  virtual Model::UpdateWorkteamOutcome UpdateWorkteam(const Model::UpdateWorkteamRequest& request) const;
 
  template <typename UpdateWorkteamRequestT = Model::UpdateWorkteamRequest>
  Model::UpdateWorkteamOutcomeCallable UpdateWorkteamCallable(const UpdateWorkteamRequestT& request) const {
    return SubmitCallable(&SageMakerClient::UpdateWorkteam, request);
  }
 
  template <typename UpdateWorkteamRequestT = Model::UpdateWorkteamRequest>
  void UpdateWorkteamAsync(const UpdateWorkteamRequestT& request, const UpdateWorkteamResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SageMakerClient::UpdateWorkteam, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<SageMakerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SageMakerClient>;
  void init(const SageMakerClientConfiguration& clientConfiguration);
 
  SageMakerClientConfiguration m_clientConfiguration;
  std::shared_ptr<SageMakerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SageMaker
}  // namespace Aws