SageMakerClient.h

 
#pragma once
#include <aws/sagemaker/SageMaker_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/sagemaker/SageMakerServiceClientModel.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::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::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::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::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::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::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::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::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::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::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::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::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::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::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 SearchTrainingPlanOfferingsRequestT& request, const SearchTrainingPlanOfferingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) 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::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