/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace SageMaker { /** *

Provides APIs for creating and managing SageMaker resources.

Other * Resources:

*/ class AWS_SAGEMAKER_API SageMakerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef SageMakerClientConfiguration ClientConfigurationType; typedef SageMakerEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SageMakerClient(const Aws::SageMaker::SageMakerClientConfiguration& clientConfiguration = Aws::SageMaker::SageMakerClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SageMakerClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SageMaker::SageMakerClientConfiguration& clientConfiguration = Aws::SageMaker::SageMakerClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ SageMakerClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::SageMaker::SageMakerClientConfiguration& clientConfiguration = Aws::SageMaker::SageMakerClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SageMakerClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ SageMakerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ SageMakerClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~SageMakerClient(); /** *

Creates an association between the source and the destination. A * source can be associated with multiple destinations, and a destination can be * associated with multiple sources. An association is a lineage tracking entity. * For more information, see Amazon * SageMaker ML Lineage Tracking.

See Also:

AWS * API Reference

*/ virtual Model::AddAssociationOutcome AddAssociation(const Model::AddAssociationRequest& request) const; /** * A Callable wrapper for AddAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddAssociationOutcomeCallable AddAssociationCallable(const AddAssociationRequestT& request) const { return SubmitCallable(&SageMakerClient::AddAssociation, request); } /** * An Async wrapper for AddAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddAssociationAsync(const AddAssociationRequestT& request, const AddAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::AddAssociation, request, handler, context); } /** *

Adds or overwrites one or more tags for the specified SageMaker resource. You * can add tags to notebook instances, training jobs, hyperparameter tuning jobs, * batch transform jobs, models, labeling jobs, work teams, endpoint * configurations, and endpoints.

Each tag consists of a key and an optional * value. Tag keys must be unique per resource. For more information about tags, * see For more information, see Amazon * Web Services Tagging Strategies.

Tags that you add to a * hyperparameter tuning job by calling this API are also added to any training * jobs that the hyperparameter tuning job launches after you call this API, but * not to training jobs that the hyperparameter tuning job launched before you * called this API. To make sure that the tags associated with a hyperparameter * tuning job are also added to all training jobs that the hyperparameter tuning * job launches, add the tags when you first create the tuning job by specifying * them in the Tags parameter of CreateHyperParameterTuningJob *

Tags that you add to a SageMaker Studio Domain or User * Profile by calling this API are also added to any Apps that the Domain or User * Profile launches after you call this API, but not to Apps that the Domain or * User Profile launched before you called this API. To make sure that the tags * associated with a Domain or User Profile are also added to all Apps that the * Domain or User Profile launches, add the tags when you first create the Domain * or User Profile by specifying them in the Tags parameter of CreateDomain * or CreateUserProfile.

*

See Also:

AWS * API Reference

*/ virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const; /** * A Callable wrapper for AddTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const { return SubmitCallable(&SageMakerClient::AddTags, request); } /** * An Async wrapper for AddTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::AddTags, request, handler, context); } /** *

Associates a trial component with a trial. A trial component can be * associated with multiple trials. To disassociate a trial component from a trial, * call the DisassociateTrialComponent * API.

See Also:

AWS * API Reference

*/ virtual Model::AssociateTrialComponentOutcome AssociateTrialComponent(const Model::AssociateTrialComponentRequest& request) const; /** * A Callable wrapper for AssociateTrialComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateTrialComponentOutcomeCallable AssociateTrialComponentCallable(const AssociateTrialComponentRequestT& request) const { return SubmitCallable(&SageMakerClient::AssociateTrialComponent, request); } /** * An Async wrapper for AssociateTrialComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateTrialComponentAsync(const AssociateTrialComponentRequestT& request, const AssociateTrialComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::AssociateTrialComponent, request, handler, context); } /** *

This action batch describes a list of versioned model packages

See * Also:

AWS * API Reference

*/ virtual Model::BatchDescribeModelPackageOutcome BatchDescribeModelPackage(const Model::BatchDescribeModelPackageRequest& request) const; /** * A Callable wrapper for BatchDescribeModelPackage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDescribeModelPackageOutcomeCallable BatchDescribeModelPackageCallable(const BatchDescribeModelPackageRequestT& request) const { return SubmitCallable(&SageMakerClient::BatchDescribeModelPackage, request); } /** * An Async wrapper for BatchDescribeModelPackage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDescribeModelPackageAsync(const BatchDescribeModelPackageRequestT& request, const BatchDescribeModelPackageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::BatchDescribeModelPackage, request, handler, context); } /** *

Creates an action. An action is a lineage tracking entity that * represents an action or activity. For example, a model deployment or an HPO job. * Generally, an action involves at least one input or output artifact. For more * information, see Amazon * SageMaker ML Lineage Tracking.

See Also:

AWS * API Reference

*/ virtual Model::CreateActionOutcome CreateAction(const Model::CreateActionRequest& request) const; /** * A Callable wrapper for CreateAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateActionOutcomeCallable CreateActionCallable(const CreateActionRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateAction, request); } /** * An Async wrapper for CreateAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateActionAsync(const CreateActionRequestT& request, const CreateActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateAction, request, handler, context); } /** *

Create a machine learning algorithm that you can use in SageMaker and list in * the Amazon Web Services Marketplace.

See Also:

AWS * API Reference

*/ virtual Model::CreateAlgorithmOutcome CreateAlgorithm(const Model::CreateAlgorithmRequest& request) const; /** * A Callable wrapper for CreateAlgorithm that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAlgorithmOutcomeCallable CreateAlgorithmCallable(const CreateAlgorithmRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateAlgorithm, request); } /** * An Async wrapper for CreateAlgorithm that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAlgorithmAsync(const CreateAlgorithmRequestT& request, const CreateAlgorithmResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateAlgorithm, request, handler, context); } /** *

Creates a running app for the specified UserProfile. This operation is * automatically invoked by Amazon SageMaker Studio upon access to the associated * Domain, and when new kernel configurations are selected by the user. A user may * have multiple Apps active simultaneously.

See Also:

AWS * API Reference

*/ virtual Model::CreateAppOutcome CreateApp(const Model::CreateAppRequest& request) const; /** * A Callable wrapper for CreateApp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAppOutcomeCallable CreateAppCallable(const CreateAppRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateApp, request); } /** * An Async wrapper for CreateApp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAppAsync(const CreateAppRequestT& request, const CreateAppResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateApp, request, handler, context); } /** *

Creates a configuration for running a SageMaker image as a KernelGateway app. * The configuration specifies the Amazon Elastic File System (EFS) storage volume * on the image, and a list of the kernels in the image.

See Also:

* AWS * API Reference

*/ virtual Model::CreateAppImageConfigOutcome CreateAppImageConfig(const Model::CreateAppImageConfigRequest& request) const; /** * A Callable wrapper for CreateAppImageConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAppImageConfigOutcomeCallable CreateAppImageConfigCallable(const CreateAppImageConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateAppImageConfig, request); } /** * An Async wrapper for CreateAppImageConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAppImageConfigAsync(const CreateAppImageConfigRequestT& request, const CreateAppImageConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateAppImageConfig, request, handler, context); } /** *

Creates an artifact. An artifact is a lineage tracking entity that * represents a URI addressable object or data. Some examples are the S3 URI of a * dataset and the ECR registry path of an image. For more information, see Amazon * SageMaker ML Lineage Tracking.

See Also:

AWS * API Reference

*/ virtual Model::CreateArtifactOutcome CreateArtifact(const Model::CreateArtifactRequest& request) const; /** * A Callable wrapper for CreateArtifact that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateArtifactOutcomeCallable CreateArtifactCallable(const CreateArtifactRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateArtifact, request); } /** * An Async wrapper for CreateArtifact that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateArtifactAsync(const CreateArtifactRequestT& request, const CreateArtifactResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateArtifact, request, handler, context); } /** *

Creates an Autopilot job also referred to as Autopilot experiment or AutoML * job.

We recommend using the new versions CreateAutoMLJobV2 * and DescribeAutoMLJobV2, * which offer backward compatibility.

CreateAutoMLJobV2 can * manage tabular problem types identical to those of its previous version * CreateAutoMLJob, as well as non-tabular problem types such as image * or text classification.

Find guidelines about how to migrate a * CreateAutoMLJob to CreateAutoMLJobV2 in Migrate * a CreateAutoMLJob to CreateAutoMLJobV2.

You can find the * best-performing model after you run an AutoML job by calling DescribeAutoMLJobV2 * (recommended) or DescribeAutoMLJob.

See * Also:

AWS * API Reference

*/ virtual Model::CreateAutoMLJobOutcome CreateAutoMLJob(const Model::CreateAutoMLJobRequest& request) const; /** * A Callable wrapper for CreateAutoMLJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAutoMLJobOutcomeCallable CreateAutoMLJobCallable(const CreateAutoMLJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateAutoMLJob, request); } /** * An Async wrapper for CreateAutoMLJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAutoMLJobAsync(const CreateAutoMLJobRequestT& request, const CreateAutoMLJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateAutoMLJob, request, handler, context); } /** *

Creates an Autopilot job also referred to as Autopilot experiment or AutoML * job V2.

CreateAutoMLJobV2 * and DescribeAutoMLJobV2 * are new versions of CreateAutoMLJob * and DescribeAutoMLJob * which offer backward compatibility.

CreateAutoMLJobV2 can * manage tabular problem types identical to those of its previous version * CreateAutoMLJob, as well as non-tabular problem types such as image * or text classification.

Find guidelines about how to migrate a * CreateAutoMLJob to CreateAutoMLJobV2 in Migrate * a CreateAutoMLJob to CreateAutoMLJobV2.

For the list of * available problem types supported by CreateAutoMLJobV2, see AutoMLProblemTypeConfig.

*

You can find the best-performing model after you run an AutoML job V2 by * calling DescribeAutoMLJobV2.

See * Also:

AWS * API Reference

*/ virtual Model::CreateAutoMLJobV2Outcome CreateAutoMLJobV2(const Model::CreateAutoMLJobV2Request& request) const; /** * A Callable wrapper for CreateAutoMLJobV2 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAutoMLJobV2OutcomeCallable CreateAutoMLJobV2Callable(const CreateAutoMLJobV2RequestT& request) const { return SubmitCallable(&SageMakerClient::CreateAutoMLJobV2, request); } /** * An Async wrapper for CreateAutoMLJobV2 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAutoMLJobV2Async(const CreateAutoMLJobV2RequestT& request, const CreateAutoMLJobV2ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateAutoMLJobV2, request, handler, context); } /** *

Creates a Git repository as a resource in your SageMaker account. You can * associate the repository with notebook instances so that you can use Git source * control for the notebooks you create. The Git repository is a resource in your * SageMaker account, so it can be associated with more than one notebook instance, * and it persists independently from the lifecycle of any notebook instances it is * associated with.

The repository can be hosted either in Amazon * Web Services CodeCommit or in any other Git repository.

See * Also:

AWS * API Reference

*/ virtual Model::CreateCodeRepositoryOutcome CreateCodeRepository(const Model::CreateCodeRepositoryRequest& request) const; /** * A Callable wrapper for CreateCodeRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCodeRepositoryOutcomeCallable CreateCodeRepositoryCallable(const CreateCodeRepositoryRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateCodeRepository, request); } /** * An Async wrapper for CreateCodeRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCodeRepositoryAsync(const CreateCodeRepositoryRequestT& request, const CreateCodeRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateCodeRepository, request, handler, context); } /** *

Starts a model compilation job. After the model has been compiled, Amazon * SageMaker saves the resulting model artifacts to an Amazon Simple Storage * Service (Amazon S3) bucket that you specify.

If you choose to host your * model using Amazon SageMaker hosting services, you can use the resulting model * artifacts as part of the model. You can also use the artifacts with Amazon Web * Services IoT Greengrass. In that case, deploy them as an ML resource.

In * the request body, you provide the following:

  • A name for the * compilation job

  • Information about the input model artifacts *

  • The output location for the compiled model and the device * (target) that the model runs on

  • The Amazon Resource Name * (ARN) of the IAM role that Amazon SageMaker assumes to perform the model * compilation job.

You can also provide a Tag to * track the model compilation job's resource use and costs. The response body * contains the CompilationJobArn for the compiled job.

To stop * a model compilation job, use StopCompilationJob. * To get information about a particular model compilation job, use DescribeCompilationJob. * To get information about multiple model compilation jobs, use ListCompilationJobs.

See * Also:

AWS * API Reference

*/ virtual Model::CreateCompilationJobOutcome CreateCompilationJob(const Model::CreateCompilationJobRequest& request) const; /** * A Callable wrapper for CreateCompilationJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCompilationJobOutcomeCallable CreateCompilationJobCallable(const CreateCompilationJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateCompilationJob, request); } /** * An Async wrapper for CreateCompilationJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCompilationJobAsync(const CreateCompilationJobRequestT& request, const CreateCompilationJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateCompilationJob, request, handler, context); } /** *

Creates a context. A context is a lineage tracking entity that * represents a logical grouping of other tracking or experiment entities. Some * examples are an endpoint and a model package. For more information, see Amazon * SageMaker ML Lineage Tracking.

See Also:

AWS * API Reference

*/ virtual Model::CreateContextOutcome CreateContext(const Model::CreateContextRequest& request) const; /** * A Callable wrapper for CreateContext that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateContextOutcomeCallable CreateContextCallable(const CreateContextRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateContext, request); } /** * An Async wrapper for CreateContext that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateContextAsync(const CreateContextRequestT& request, const CreateContextResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateContext, request, handler, context); } /** *

Creates a definition for a job that monitors data quality and drift. For * information about model monitor, see Amazon * SageMaker Model Monitor.

See Also:

AWS * API Reference

*/ virtual Model::CreateDataQualityJobDefinitionOutcome CreateDataQualityJobDefinition(const Model::CreateDataQualityJobDefinitionRequest& request) const; /** * A Callable wrapper for CreateDataQualityJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDataQualityJobDefinitionOutcomeCallable CreateDataQualityJobDefinitionCallable(const CreateDataQualityJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateDataQualityJobDefinition, request); } /** * An Async wrapper for CreateDataQualityJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDataQualityJobDefinitionAsync(const CreateDataQualityJobDefinitionRequestT& request, const CreateDataQualityJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateDataQualityJobDefinition, request, handler, context); } /** *

Creates a device fleet.

See Also:

AWS * API Reference

*/ virtual Model::CreateDeviceFleetOutcome CreateDeviceFleet(const Model::CreateDeviceFleetRequest& request) const; /** * A Callable wrapper for CreateDeviceFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDeviceFleetOutcomeCallable CreateDeviceFleetCallable(const CreateDeviceFleetRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateDeviceFleet, request); } /** * An Async wrapper for CreateDeviceFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDeviceFleetAsync(const CreateDeviceFleetRequestT& request, const CreateDeviceFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateDeviceFleet, request, handler, context); } /** *

Creates a Domain used by Amazon SageMaker Studio. A domain * consists of an associated Amazon Elastic File System (EFS) volume, a list of * authorized users, and a variety of security, application, policy, and Amazon * Virtual Private Cloud (VPC) configurations. Users within a domain can share * notebook files and other artifacts with each other.

EFS storage *

When a domain is created, an EFS volume is created for use by all of the * users within the domain. Each user receives a private home directory within the * EFS volume for notebooks, Git repositories, and data files.

SageMaker * uses the Amazon Web Services Key Management Service (Amazon Web Services KMS) to * encrypt the EFS volume attached to the domain with an Amazon Web Services * managed key by default. For more control, you can specify a customer managed * key. For more information, see Protect * Data at Rest Using Encryption.

VPC configuration

All * SageMaker Studio traffic between the domain and the EFS volume is through the * specified VPC and subnets. For other Studio traffic, you can specify the * AppNetworkAccessType parameter. AppNetworkAccessType * corresponds to the network access type that you choose when you onboard to * Studio. The following options are available:

  • * PublicInternetOnly - Non-EFS traffic goes through a VPC managed by * Amazon SageMaker, which allows internet access. This is the default value.

    *

  • VpcOnly - All Studio traffic is through the * specified VPC and subnets. Internet access is disabled by default. To allow * internet access, you must specify a NAT gateway.

    When internet access is * disabled, you won't be able to run a Studio notebook or to train or host models * unless your VPC has an interface endpoint to the SageMaker API and runtime or a * NAT gateway and your security groups allow outbound connections.

*

NFS traffic over TCP on port 2049 needs to be allowed in both * inbound and outbound rules in order to launch a SageMaker Studio app * successfully.

For more information, see Connect * SageMaker Studio Notebooks to Resources in a VPC.

See Also:

* AWS * API Reference

*/ virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const; /** * A Callable wrapper for CreateDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateDomain, request); } /** * An Async wrapper for CreateDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateDomain, request, handler, context); } /** *

Creates an edge deployment plan, consisting of multiple stages. Each stage * may have a different deployment configuration and devices.

See * Also:

AWS * API Reference

*/ virtual Model::CreateEdgeDeploymentPlanOutcome CreateEdgeDeploymentPlan(const Model::CreateEdgeDeploymentPlanRequest& request) const; /** * A Callable wrapper for CreateEdgeDeploymentPlan that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEdgeDeploymentPlanOutcomeCallable CreateEdgeDeploymentPlanCallable(const CreateEdgeDeploymentPlanRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateEdgeDeploymentPlan, request); } /** * An Async wrapper for CreateEdgeDeploymentPlan that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEdgeDeploymentPlanAsync(const CreateEdgeDeploymentPlanRequestT& request, const CreateEdgeDeploymentPlanResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateEdgeDeploymentPlan, request, handler, context); } /** *

Creates a new stage in an existing edge deployment plan.

See * Also:

AWS * API Reference

*/ virtual Model::CreateEdgeDeploymentStageOutcome CreateEdgeDeploymentStage(const Model::CreateEdgeDeploymentStageRequest& request) const; /** * A Callable wrapper for CreateEdgeDeploymentStage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEdgeDeploymentStageOutcomeCallable CreateEdgeDeploymentStageCallable(const CreateEdgeDeploymentStageRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateEdgeDeploymentStage, request); } /** * An Async wrapper for CreateEdgeDeploymentStage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEdgeDeploymentStageAsync(const CreateEdgeDeploymentStageRequestT& request, const CreateEdgeDeploymentStageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateEdgeDeploymentStage, request, handler, context); } /** *

Starts a SageMaker Edge Manager model packaging job. Edge Manager will use * the model artifacts from the Amazon Simple Storage Service bucket that you * specify. After the model has been packaged, Amazon SageMaker saves the resulting * artifacts to an S3 bucket that you specify.

See Also:

AWS * API Reference

*/ virtual Model::CreateEdgePackagingJobOutcome CreateEdgePackagingJob(const Model::CreateEdgePackagingJobRequest& request) const; /** * A Callable wrapper for CreateEdgePackagingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEdgePackagingJobOutcomeCallable CreateEdgePackagingJobCallable(const CreateEdgePackagingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateEdgePackagingJob, request); } /** * An Async wrapper for CreateEdgePackagingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEdgePackagingJobAsync(const CreateEdgePackagingJobRequestT& request, const CreateEdgePackagingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateEdgePackagingJob, request, handler, context); } /** *

Creates an endpoint using the endpoint configuration specified in the * request. SageMaker uses the endpoint to provision resources and deploy models. * You create the endpoint configuration with the CreateEndpointConfig * API.

Use this API to deploy models using SageMaker hosting services. *

For an example that calls this method when deploying a model to * SageMaker hosting services, see the Create * Endpoint example notebook.

You must not delete an * EndpointConfig that is in use by an endpoint that is live or while * the UpdateEndpoint or CreateEndpoint operations are * being performed on the endpoint. To update an endpoint, you must create a new * EndpointConfig.

The endpoint name must be unique * within an Amazon Web Services Region in your Amazon Web Services account.

*

When it receives the request, SageMaker creates the endpoint, launches the * resources (ML compute instances), and deploys the model(s) on them.

*

When you call CreateEndpoint, * a load call is made to DynamoDB to verify that your endpoint configuration * exists. When you read data from a DynamoDB table supporting * Eventually Consistent Reads , the response might not reflect * the results of a recently completed write operation. The response might include * some stale data. If the dependent entities are not yet in DynamoDB, this causes * a validation error. If you repeat your read request after a short time, the * response should return the latest data. So retry logic is recommended to handle * these possible issues. We also recommend that customers call DescribeEndpointConfig * before calling CreateEndpoint * to minimize the potential impact of a DynamoDB eventually consistent read.

*

When SageMaker receives the request, it sets the endpoint status to * Creating. After it creates the endpoint, it sets the status to * InService. SageMaker can then process incoming requests for * inferences. To check the status of an endpoint, use the DescribeEndpoint * API.

If any of the models hosted at this endpoint get model data from an * Amazon S3 location, SageMaker uses Amazon Web Services Security Token Service to * download model artifacts from the S3 path you provided. Amazon Web Services STS * is activated in your Amazon Web Services account by default. If you previously * deactivated Amazon Web Services STS for a region, you need to reactivate Amazon * Web Services STS for that region. For more information, see Activating * and Deactivating Amazon Web Services STS in an Amazon Web Services Region in * the Amazon Web Services Identity and Access Management User Guide.

*

To add the IAM role policies for using this API operation, go to the * IAM console, and choose Roles * in the left navigation pane. Search the IAM role that you want to grant access * to use the CreateEndpoint * and CreateEndpointConfig * API operations, add the following policies to the role.

  • Option * 1: For a full SageMaker access, search and attach the * AmazonSageMakerFullAccess policy.

  • Option 2: For * granting a limited access to an IAM role, paste the following Action elements * manually into the JSON file of the IAM role:

    "Action": * ["sagemaker:CreateEndpoint", "sagemaker:CreateEndpointConfig"]

    * "Resource": [

    * "arn:aws:sagemaker:region:account-id:endpoint/endpointName"

    *

    * "arn:aws:sagemaker:region:account-id:endpoint-config/endpointConfigName" *

    ]

    For more information, see SageMaker * API Permissions: Actions, Permissions, and Resources Reference.

    • *

See Also:

AWS * API Reference

*/ virtual Model::CreateEndpointOutcome CreateEndpoint(const Model::CreateEndpointRequest& request) const; /** * A Callable wrapper for CreateEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEndpointOutcomeCallable CreateEndpointCallable(const CreateEndpointRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateEndpoint, request); } /** * An Async wrapper for CreateEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEndpointAsync(const CreateEndpointRequestT& request, const CreateEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateEndpoint, request, handler, context); } /** *

Creates an endpoint configuration that SageMaker hosting services uses to * deploy models. In the configuration, you identify one or more models, created * using the CreateModel API, to deploy and the resources that you * want SageMaker to provision. Then you call the CreateEndpoint * API.

Use this API if you want to use SageMaker hosting services * to deploy models into production.

In the request, you define a * ProductionVariant, for each model that you want to deploy. Each * ProductionVariant parameter also describes the resources that you * want SageMaker to provision. This includes the number and type of ML compute * instances to deploy.

If you are hosting multiple models, you also assign * a VariantWeight to specify how much traffic you want to allocate to * each model. For example, suppose that you want to host two models, A and B, and * you assign traffic weight 2 for model A and 1 for model B. SageMaker distributes * two-thirds of the traffic to Model A, and one-third to model B.

*

When you call CreateEndpoint, * a load call is made to DynamoDB to verify that your endpoint configuration * exists. When you read data from a DynamoDB table supporting * Eventually Consistent Reads , the response might not reflect * the results of a recently completed write operation. The response might include * some stale data. If the dependent entities are not yet in DynamoDB, this causes * a validation error. If you repeat your read request after a short time, the * response should return the latest data. So retry logic is recommended to handle * these possible issues. We also recommend that customers call DescribeEndpointConfig * before calling CreateEndpoint * to minimize the potential impact of a DynamoDB eventually consistent read.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateEndpointConfigOutcome CreateEndpointConfig(const Model::CreateEndpointConfigRequest& request) const; /** * A Callable wrapper for CreateEndpointConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEndpointConfigOutcomeCallable CreateEndpointConfigCallable(const CreateEndpointConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateEndpointConfig, request); } /** * An Async wrapper for CreateEndpointConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEndpointConfigAsync(const CreateEndpointConfigRequestT& request, const CreateEndpointConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateEndpointConfig, request, handler, context); } /** *

Creates a SageMaker experiment. An experiment is a collection of * trials that are observed, compared and evaluated as a group. A trial is a * set of steps, called trial components, that produce a machine learning * model.

In the Studio UI, trials are referred to as run * groups and trial components are referred to as runs.

*

The goal of an experiment is to determine the components that produce the * best model. Multiple trials are performed, each one isolating and measuring the * impact of a change to one or more inputs, while keeping the remaining inputs * constant.

When you use SageMaker Studio or the SageMaker Python SDK, all * experiments, trials, and trial components are automatically tracked, logged, and * indexed. When you use the Amazon Web Services SDK for Python (Boto), you must * use the logging APIs provided by the SDK.

You can add tags to * experiments, trials, trial components and then use the Search * API to search for the tags.

To add a description to an experiment, * specify the optional Description parameter. To add a description * later, or to change the description, call the UpdateExperiment * API.

To get a list of all your experiments, call the ListExperiments * API. To view an experiment's properties, call the DescribeExperiment * API. To get a list of all the trials associated with an experiment, call the ListTrials * API. To create a trial call the CreateTrial * API.

See Also:

AWS * API Reference

*/ virtual Model::CreateExperimentOutcome CreateExperiment(const Model::CreateExperimentRequest& request) const; /** * A Callable wrapper for CreateExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateExperimentOutcomeCallable CreateExperimentCallable(const CreateExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateExperiment, request); } /** * An Async wrapper for CreateExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateExperimentAsync(const CreateExperimentRequestT& request, const CreateExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateExperiment, request, handler, context); } /** *

Create a new FeatureGroup. A FeatureGroup is a * group of Features defined in the FeatureStore to * describe a Record.

The FeatureGroup defines * the schema and features contained in the FeatureGroup. A * FeatureGroup definition is composed of a list of * Features, a RecordIdentifierFeatureName, an * EventTimeFeatureName and configurations for its * OnlineStore and OfflineStore. Check Amazon * Web Services service quotas to see the FeatureGroups quota for * your Amazon Web Services account.

You must include at least * one of OnlineStoreConfig and OfflineStoreConfig to * create a FeatureGroup.

See Also:

AWS * API Reference

*/ virtual Model::CreateFeatureGroupOutcome CreateFeatureGroup(const Model::CreateFeatureGroupRequest& request) const; /** * A Callable wrapper for CreateFeatureGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFeatureGroupOutcomeCallable CreateFeatureGroupCallable(const CreateFeatureGroupRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateFeatureGroup, request); } /** * An Async wrapper for CreateFeatureGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFeatureGroupAsync(const CreateFeatureGroupRequestT& request, const CreateFeatureGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateFeatureGroup, request, handler, context); } /** *

Creates a flow definition.

See Also:

AWS * API Reference

*/ virtual Model::CreateFlowDefinitionOutcome CreateFlowDefinition(const Model::CreateFlowDefinitionRequest& request) const; /** * A Callable wrapper for CreateFlowDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFlowDefinitionOutcomeCallable CreateFlowDefinitionCallable(const CreateFlowDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateFlowDefinition, request); } /** * An Async wrapper for CreateFlowDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFlowDefinitionAsync(const CreateFlowDefinitionRequestT& request, const CreateFlowDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateFlowDefinition, request, handler, context); } /** *

Create a hub.

Hub APIs are only callable through SageMaker * Studio.

See Also:

AWS * API Reference

*/ virtual Model::CreateHubOutcome CreateHub(const Model::CreateHubRequest& request) const; /** * A Callable wrapper for CreateHub that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateHubOutcomeCallable CreateHubCallable(const CreateHubRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateHub, request); } /** * An Async wrapper for CreateHub that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateHubAsync(const CreateHubRequestT& request, const CreateHubResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateHub, request, handler, context); } /** *

Defines the settings you will use for the human review workflow user * interface. Reviewers will see a three-panel interface with an instruction area, * the item to review, and an input area.

See Also:

AWS * API Reference

*/ virtual Model::CreateHumanTaskUiOutcome CreateHumanTaskUi(const Model::CreateHumanTaskUiRequest& request) const; /** * A Callable wrapper for CreateHumanTaskUi that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateHumanTaskUiOutcomeCallable CreateHumanTaskUiCallable(const CreateHumanTaskUiRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateHumanTaskUi, request); } /** * An Async wrapper for CreateHumanTaskUi that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateHumanTaskUiAsync(const CreateHumanTaskUiRequestT& request, const CreateHumanTaskUiResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateHumanTaskUi, request, handler, context); } /** *

Starts a hyperparameter tuning job. A hyperparameter tuning job finds the * best version of a model by running many training jobs on your dataset using the * algorithm you choose and values for hyperparameters within ranges that you * specify. It then chooses the hyperparameter values that result in a model that * performs the best, as measured by an objective metric that you choose.

A * hyperparameter tuning job automatically creates Amazon SageMaker experiments, * trials, and trial components for each training job that it runs. You can view * these entities in Amazon SageMaker Studio. For more information, see View * Experiments, Trials, and Trial Components.

Do not include * any security-sensitive information including account access IDs, secrets or * tokens in any hyperparameter field. If the use of security-sensitive credentials * are detected, SageMaker will reject your training job request and return an * exception error.

See Also:

AWS * API Reference

*/ virtual Model::CreateHyperParameterTuningJobOutcome CreateHyperParameterTuningJob(const Model::CreateHyperParameterTuningJobRequest& request) const; /** * A Callable wrapper for CreateHyperParameterTuningJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateHyperParameterTuningJobOutcomeCallable CreateHyperParameterTuningJobCallable(const CreateHyperParameterTuningJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateHyperParameterTuningJob, request); } /** * An Async wrapper for CreateHyperParameterTuningJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateHyperParameterTuningJobAsync(const CreateHyperParameterTuningJobRequestT& request, const CreateHyperParameterTuningJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateHyperParameterTuningJob, request, handler, context); } /** *

Creates a custom SageMaker image. A SageMaker image is a set of image * versions. Each image version represents a container image stored in Amazon * Elastic Container Registry (ECR). For more information, see Bring * your own SageMaker image.

See Also:

AWS * API Reference

*/ virtual Model::CreateImageOutcome CreateImage(const Model::CreateImageRequest& request) const; /** * A Callable wrapper for CreateImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateImageOutcomeCallable CreateImageCallable(const CreateImageRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateImage, request); } /** * An Async wrapper for CreateImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateImageAsync(const CreateImageRequestT& request, const CreateImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateImage, request, handler, context); } /** *

Creates a version of the SageMaker image specified by ImageName. * The version represents the Amazon Elastic Container Registry (ECR) container * image specified by BaseImage.

See Also:

AWS * API Reference

*/ virtual Model::CreateImageVersionOutcome CreateImageVersion(const Model::CreateImageVersionRequest& request) const; /** * A Callable wrapper for CreateImageVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateImageVersionOutcomeCallable CreateImageVersionCallable(const CreateImageVersionRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateImageVersion, request); } /** * An Async wrapper for CreateImageVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateImageVersionAsync(const CreateImageVersionRequestT& request, const CreateImageVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateImageVersion, request, handler, context); } /** *

Creates an inference experiment using the configurations specified in the * request.

Use this API to setup and schedule an experiment to compare * model variants on a Amazon SageMaker inference endpoint. For more information * about inference experiments, see Shadow * tests.

Amazon SageMaker begins your experiment at the scheduled * time and routes traffic to your endpoint's model variants based on your * specified configuration.

While the experiment is in progress or after * it has concluded, you can view metrics that compare your model variants. For * more information, see View, * monitor, and edit shadow tests.

See Also:

AWS * API Reference

*/ virtual Model::CreateInferenceExperimentOutcome CreateInferenceExperiment(const Model::CreateInferenceExperimentRequest& request) const; /** * A Callable wrapper for CreateInferenceExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInferenceExperimentOutcomeCallable CreateInferenceExperimentCallable(const CreateInferenceExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateInferenceExperiment, request); } /** * An Async wrapper for CreateInferenceExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInferenceExperimentAsync(const CreateInferenceExperimentRequestT& request, const CreateInferenceExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateInferenceExperiment, request, handler, context); } /** *

Starts a recommendation job. You can create either an instance recommendation * or load test job.

See Also:

AWS * API Reference

*/ virtual Model::CreateInferenceRecommendationsJobOutcome CreateInferenceRecommendationsJob(const Model::CreateInferenceRecommendationsJobRequest& request) const; /** * A Callable wrapper for CreateInferenceRecommendationsJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInferenceRecommendationsJobOutcomeCallable CreateInferenceRecommendationsJobCallable(const CreateInferenceRecommendationsJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateInferenceRecommendationsJob, request); } /** * An Async wrapper for CreateInferenceRecommendationsJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInferenceRecommendationsJobAsync(const CreateInferenceRecommendationsJobRequestT& request, const CreateInferenceRecommendationsJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateInferenceRecommendationsJob, request, handler, context); } /** *

Creates a job that uses workers to label the data objects in your input * dataset. You can use the labeled data to train machine learning models.

*

You can select your workforce from one of three providers:

  • A * private workforce that you create. It can include employees, contractors, and * outside experts. Use a private workforce when want the data to stay within your * organization or when a specific set of skills is required.

  • One * or more vendors that you select from the Amazon Web Services Marketplace. * Vendors provide expertise in specific areas.

  • The Amazon * Mechanical Turk workforce. This is the largest workforce, but it should only be * used for public data or data that has been stripped of any personally * identifiable information.

You can also use automated data * labeling to reduce the number of data objects that need to be labeled by a * human. Automated data labeling uses active learning to determine if a * data object can be labeled by machine or if it needs to be sent to a human * worker. For more information, see Using * Automated Data Labeling.

The data objects to be labeled are contained * in an Amazon S3 bucket. You create a manifest file that describes the * location of each object. For more information, see Using Input * and Output Data.

The output can be used as the manifest file for * another labeling job or as training data for your machine learning models.

*

You can use this operation to create a static labeling job or a streaming * labeling job. A static labeling job stops if all data objects in the input * manifest file identified in ManifestS3Uri have been labeled. A * streaming labeling job runs perpetually until it is manually stopped, or remains * idle for 10 days. You can send new data objects to an active * (InProgress) streaming labeling job in real time. To learn how to * create a static labeling job, see Create * a Labeling Job (API) in the Amazon SageMaker Developer Guide. To learn how * to create a streaming labeling job, see Create * a Streaming Labeling Job.

See Also:

AWS * API Reference

*/ virtual Model::CreateLabelingJobOutcome CreateLabelingJob(const Model::CreateLabelingJobRequest& request) const; /** * A Callable wrapper for CreateLabelingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateLabelingJobOutcomeCallable CreateLabelingJobCallable(const CreateLabelingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateLabelingJob, request); } /** * An Async wrapper for CreateLabelingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateLabelingJobAsync(const CreateLabelingJobRequestT& request, const CreateLabelingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateLabelingJob, request, handler, context); } /** *

Creates a model in SageMaker. In the request, you name the model and describe * a primary container. For the primary container, you specify the Docker image * that contains inference code, artifacts (from prior training), and a custom * environment map that the inference code uses when you deploy the model for * predictions.

Use this API to create a model if you want to use SageMaker * hosting services or run a batch transform job.

To host your model, you * create an endpoint configuration with the CreateEndpointConfig API, * and then create an endpoint with the CreateEndpoint API. SageMaker * then deploys all of the containers that you defined for the model in the hosting * environment.

For an example that calls this method when deploying a * model to SageMaker hosting services, see Create * a Model (Amazon Web Services SDK for Python (Boto 3)).

To run a * batch transform using your model, you start a job with the * CreateTransformJob API. SageMaker uses your model and your dataset * to get inferences which are then saved to a specified S3 location.

In the * request, you also provide an IAM role that SageMaker can assume to access model * artifacts and docker image for deployment on ML compute hosting instances or for * batch transform jobs. In addition, you also use the IAM role to manage * permissions the inference code needs. For example, if the inference code access * any other Amazon Web Services resources, you grant necessary permissions via * this role.

See Also:

AWS * API Reference

*/ virtual Model::CreateModelOutcome CreateModel(const Model::CreateModelRequest& request) const; /** * A Callable wrapper for CreateModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelOutcomeCallable CreateModelCallable(const CreateModelRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateModel, request); } /** * An Async wrapper for CreateModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelAsync(const CreateModelRequestT& request, const CreateModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateModel, request, handler, context); } /** *

Creates the definition for a model bias job.

See Also:

AWS * API Reference

*/ virtual Model::CreateModelBiasJobDefinitionOutcome CreateModelBiasJobDefinition(const Model::CreateModelBiasJobDefinitionRequest& request) const; /** * A Callable wrapper for CreateModelBiasJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelBiasJobDefinitionOutcomeCallable CreateModelBiasJobDefinitionCallable(const CreateModelBiasJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateModelBiasJobDefinition, request); } /** * An Async wrapper for CreateModelBiasJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelBiasJobDefinitionAsync(const CreateModelBiasJobDefinitionRequestT& request, const CreateModelBiasJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateModelBiasJobDefinition, request, handler, context); } /** *

Creates an Amazon SageMaker Model Card.

For information about how to * use model cards, see Amazon * SageMaker Model Card.

See Also:

AWS * API Reference

*/ virtual Model::CreateModelCardOutcome CreateModelCard(const Model::CreateModelCardRequest& request) const; /** * A Callable wrapper for CreateModelCard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelCardOutcomeCallable CreateModelCardCallable(const CreateModelCardRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateModelCard, request); } /** * An Async wrapper for CreateModelCard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelCardAsync(const CreateModelCardRequestT& request, const CreateModelCardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateModelCard, request, handler, context); } /** *

Creates an Amazon SageMaker Model Card export job.

See Also:

* AWS * API Reference

*/ virtual Model::CreateModelCardExportJobOutcome CreateModelCardExportJob(const Model::CreateModelCardExportJobRequest& request) const; /** * A Callable wrapper for CreateModelCardExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelCardExportJobOutcomeCallable CreateModelCardExportJobCallable(const CreateModelCardExportJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateModelCardExportJob, request); } /** * An Async wrapper for CreateModelCardExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelCardExportJobAsync(const CreateModelCardExportJobRequestT& request, const CreateModelCardExportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateModelCardExportJob, request, handler, context); } /** *

Creates the definition for a model explainability job.

See * Also:

AWS * API Reference

*/ virtual Model::CreateModelExplainabilityJobDefinitionOutcome CreateModelExplainabilityJobDefinition(const Model::CreateModelExplainabilityJobDefinitionRequest& request) const; /** * A Callable wrapper for CreateModelExplainabilityJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelExplainabilityJobDefinitionOutcomeCallable CreateModelExplainabilityJobDefinitionCallable(const CreateModelExplainabilityJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateModelExplainabilityJobDefinition, request); } /** * An Async wrapper for CreateModelExplainabilityJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelExplainabilityJobDefinitionAsync(const CreateModelExplainabilityJobDefinitionRequestT& request, const CreateModelExplainabilityJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateModelExplainabilityJobDefinition, request, handler, context); } /** *

Creates a model package that you can use to create SageMaker models or list * on Amazon Web Services Marketplace, or a versioned model that is part of a model * group. Buyers can subscribe to model packages listed on Amazon Web Services * Marketplace to create models in SageMaker.

To create a model package by * specifying a Docker container that contains your inference code and the Amazon * S3 location of your model artifacts, provide values for * InferenceSpecification. To create a model from an algorithm * resource that you created or subscribed to in Amazon Web Services Marketplace, * provide a value for SourceAlgorithmSpecification.

*

There are two types of model packages:

  • Versioned - a model * that is part of a model group in the model registry.

  • *

    Unversioned - a model package that is not part of a model group.

    • *

See Also:

AWS * API Reference

*/ virtual Model::CreateModelPackageOutcome CreateModelPackage(const Model::CreateModelPackageRequest& request) const; /** * A Callable wrapper for CreateModelPackage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelPackageOutcomeCallable CreateModelPackageCallable(const CreateModelPackageRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateModelPackage, request); } /** * An Async wrapper for CreateModelPackage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelPackageAsync(const CreateModelPackageRequestT& request, const CreateModelPackageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateModelPackage, request, handler, context); } /** *

Creates a model group. A model group contains a group of model * versions.

See Also:

AWS * API Reference

*/ virtual Model::CreateModelPackageGroupOutcome CreateModelPackageGroup(const Model::CreateModelPackageGroupRequest& request) const; /** * A Callable wrapper for CreateModelPackageGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelPackageGroupOutcomeCallable CreateModelPackageGroupCallable(const CreateModelPackageGroupRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateModelPackageGroup, request); } /** * An Async wrapper for CreateModelPackageGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelPackageGroupAsync(const CreateModelPackageGroupRequestT& request, const CreateModelPackageGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateModelPackageGroup, request, handler, context); } /** *

Creates a definition for a job that monitors model quality and drift. For * information about model monitor, see Amazon * SageMaker Model Monitor.

See Also:

AWS * API Reference

*/ virtual Model::CreateModelQualityJobDefinitionOutcome CreateModelQualityJobDefinition(const Model::CreateModelQualityJobDefinitionRequest& request) const; /** * A Callable wrapper for CreateModelQualityJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateModelQualityJobDefinitionOutcomeCallable CreateModelQualityJobDefinitionCallable(const CreateModelQualityJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateModelQualityJobDefinition, request); } /** * An Async wrapper for CreateModelQualityJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateModelQualityJobDefinitionAsync(const CreateModelQualityJobDefinitionRequestT& request, const CreateModelQualityJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateModelQualityJobDefinition, request, handler, context); } /** *

Creates a schedule that regularly starts Amazon SageMaker Processing Jobs to * monitor the data captured for an Amazon SageMaker Endpoint.

See * Also:

AWS * API Reference

*/ virtual Model::CreateMonitoringScheduleOutcome CreateMonitoringSchedule(const Model::CreateMonitoringScheduleRequest& request) const; /** * A Callable wrapper for CreateMonitoringSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateMonitoringScheduleOutcomeCallable CreateMonitoringScheduleCallable(const CreateMonitoringScheduleRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateMonitoringSchedule, request); } /** * An Async wrapper for CreateMonitoringSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateMonitoringScheduleAsync(const CreateMonitoringScheduleRequestT& request, const CreateMonitoringScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateMonitoringSchedule, request, handler, context); } /** *

Creates an SageMaker notebook instance. A notebook instance is a machine * learning (ML) compute instance running on a Jupyter notebook.

In a * CreateNotebookInstance request, specify the type of ML compute * instance that you want to run. SageMaker launches the instance, installs common * libraries that you can use to explore datasets for model training, and attaches * an ML storage volume to the notebook instance.

SageMaker also provides a * set of example notebooks. Each notebook demonstrates how to use SageMaker with a * specific algorithm or with a machine learning framework.

After receiving * the request, SageMaker does the following:

  1. Creates a network * interface in the SageMaker VPC.

  2. (Option) If you specified * SubnetId, SageMaker creates a network interface in your own VPC, * which is inferred from the subnet ID that you provide in the input. When * creating this network interface, SageMaker attaches the security group that you * specified in the request to the network interface that it creates in your * VPC.

  3. Launches an EC2 instance of the type specified in the * request in the SageMaker VPC. If you specified SubnetId of your * VPC, SageMaker specifies both network interfaces when launching this instance. * This enables inbound traffic from your own VPC to the notebook instance, * assuming that the security groups allow it.

After creating * the notebook instance, SageMaker returns its Amazon Resource Name (ARN). You * can't change the name of a notebook instance after you create it.

After * SageMaker creates the notebook instance, you can connect to the Jupyter server * and work in Jupyter notebooks. For example, you can write code to explore a * dataset that you can use for model training, train a model, host models by * creating SageMaker endpoints, and validate hosted models.

For more * information, see How It * Works.

See Also:

AWS * API Reference

*/ virtual Model::CreateNotebookInstanceOutcome CreateNotebookInstance(const Model::CreateNotebookInstanceRequest& request) const; /** * A Callable wrapper for CreateNotebookInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNotebookInstanceOutcomeCallable CreateNotebookInstanceCallable(const CreateNotebookInstanceRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateNotebookInstance, request); } /** * An Async wrapper for CreateNotebookInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNotebookInstanceAsync(const CreateNotebookInstanceRequestT& request, const CreateNotebookInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateNotebookInstance, request, handler, context); } /** *

Creates a lifecycle configuration that you can associate with a notebook * instance. A lifecycle configuration is a collection of shell scripts that * run when you create or start a notebook instance.

Each lifecycle * configuration script has a limit of 16384 characters.

The value of the * $PATH environment variable that is available to both scripts is * /sbin:bin:/usr/sbin:/usr/bin.

View CloudWatch Logs for * notebook instance lifecycle configurations in log group * /aws/sagemaker/NotebookInstances in log stream * [notebook-instance-name]/[LifecycleConfigHook].

Lifecycle * configuration scripts cannot run for longer than 5 minutes. If a script runs for * longer than 5 minutes, it fails and the notebook instance is not created or * started.

For information about notebook instance lifestyle * configurations, see Step * 2.1: (Optional) Customize a Notebook Instance.

See Also:

AWS * API Reference

*/ virtual Model::CreateNotebookInstanceLifecycleConfigOutcome CreateNotebookInstanceLifecycleConfig(const Model::CreateNotebookInstanceLifecycleConfigRequest& request) const; /** * A Callable wrapper for CreateNotebookInstanceLifecycleConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateNotebookInstanceLifecycleConfigOutcomeCallable CreateNotebookInstanceLifecycleConfigCallable(const CreateNotebookInstanceLifecycleConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateNotebookInstanceLifecycleConfig, request); } /** * An Async wrapper for CreateNotebookInstanceLifecycleConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateNotebookInstanceLifecycleConfigAsync(const CreateNotebookInstanceLifecycleConfigRequestT& request, const CreateNotebookInstanceLifecycleConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateNotebookInstanceLifecycleConfig, request, handler, context); } /** *

Creates a pipeline using a JSON pipeline definition.

See Also:

* AWS * API Reference

*/ virtual Model::CreatePipelineOutcome CreatePipeline(const Model::CreatePipelineRequest& request) const; /** * A Callable wrapper for CreatePipeline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePipelineOutcomeCallable CreatePipelineCallable(const CreatePipelineRequestT& request) const { return SubmitCallable(&SageMakerClient::CreatePipeline, request); } /** * An Async wrapper for CreatePipeline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePipelineAsync(const CreatePipelineRequestT& request, const CreatePipelineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreatePipeline, request, handler, context); } /** *

Creates a URL for a specified UserProfile in a Domain. When accessed in a web * browser, the user will be automatically signed in to Amazon SageMaker Studio, * and granted access to all of the Apps and files associated with the Domain's * Amazon Elastic File System (EFS) volume. This operation can only be called when * the authentication mode equals IAM.

The IAM role or user passed to this * API defines the permissions to access the app. Once the presigned URL is * created, no additional permission is required to access this URL. IAM * authorization policies for this API are also enforced for every HTTP request and * WebSocket frame that attempts to connect to the app.

You can restrict * access to this API and to the URL that it returns to a list of IP addresses, * Amazon VPCs or Amazon VPC Endpoints that you specify. For more information, see * Connect * to SageMaker Studio Through an Interface VPC Endpoint .

The * URL that you get from a call to CreatePresignedDomainUrl has a * default timeout of 5 minutes. You can configure this value using * ExpiresInSeconds. If you try to use the URL after the timeout limit * expires, you are directed to the Amazon Web Services console sign-in page.

*

See Also:

AWS * API Reference

*/ virtual Model::CreatePresignedDomainUrlOutcome CreatePresignedDomainUrl(const Model::CreatePresignedDomainUrlRequest& request) const; /** * A Callable wrapper for CreatePresignedDomainUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePresignedDomainUrlOutcomeCallable CreatePresignedDomainUrlCallable(const CreatePresignedDomainUrlRequestT& request) const { return SubmitCallable(&SageMakerClient::CreatePresignedDomainUrl, request); } /** * An Async wrapper for CreatePresignedDomainUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePresignedDomainUrlAsync(const CreatePresignedDomainUrlRequestT& request, const CreatePresignedDomainUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreatePresignedDomainUrl, request, handler, context); } /** *

Returns a URL that you can use to connect to the Jupyter server from a * notebook instance. In the SageMaker console, when you choose Open * next to a notebook instance, SageMaker opens a new tab showing the Jupyter * server home page from the notebook instance. The console uses this API to get * the URL and show the page.

The IAM role or user used to call this API * defines the permissions to access the notebook instance. Once the presigned URL * is created, no additional permission is required to access this URL. IAM * authorization policies for this API are also enforced for every HTTP request and * WebSocket frame that attempts to connect to the notebook instance.

You * can restrict access to this API and to the URL that it returns to a list of IP * addresses that you specify. Use the NotIpAddress condition operator * and the aws:SourceIP condition context key to specify the list of * IP addresses that you want to have access to the notebook instance. For more * information, see Limit * Access to a Notebook Instance by IP Address.

The URL that you * get from a call to CreatePresignedNotebookInstanceUrl * is valid only for 5 minutes. If you try to use the URL after the 5-minute limit * expires, you are directed to the Amazon Web Services console sign-in page.

*

See Also:

AWS * API Reference

*/ virtual Model::CreatePresignedNotebookInstanceUrlOutcome CreatePresignedNotebookInstanceUrl(const Model::CreatePresignedNotebookInstanceUrlRequest& request) const; /** * A Callable wrapper for CreatePresignedNotebookInstanceUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePresignedNotebookInstanceUrlOutcomeCallable CreatePresignedNotebookInstanceUrlCallable(const CreatePresignedNotebookInstanceUrlRequestT& request) const { return SubmitCallable(&SageMakerClient::CreatePresignedNotebookInstanceUrl, request); } /** * An Async wrapper for CreatePresignedNotebookInstanceUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePresignedNotebookInstanceUrlAsync(const CreatePresignedNotebookInstanceUrlRequestT& request, const CreatePresignedNotebookInstanceUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreatePresignedNotebookInstanceUrl, request, handler, context); } /** *

Creates a processing job.

See Also:

AWS * API Reference

*/ virtual Model::CreateProcessingJobOutcome CreateProcessingJob(const Model::CreateProcessingJobRequest& request) const; /** * A Callable wrapper for CreateProcessingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProcessingJobOutcomeCallable CreateProcessingJobCallable(const CreateProcessingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateProcessingJob, request); } /** * An Async wrapper for CreateProcessingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProcessingJobAsync(const CreateProcessingJobRequestT& request, const CreateProcessingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateProcessingJob, request, handler, context); } /** *

Creates a machine learning (ML) project that can contain one or more * templates that set up an ML pipeline from training to deploying an approved * model.

See Also:

AWS * API Reference

*/ virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const; /** * A Callable wrapper for CreateProject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateProject, request); } /** * An Async wrapper for CreateProject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateProject, request, handler, context); } /** *

Creates a space used for real time collaboration in a Domain.

See * Also:

AWS * API Reference

*/ virtual Model::CreateSpaceOutcome CreateSpace(const Model::CreateSpaceRequest& request) const; /** * A Callable wrapper for CreateSpace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSpaceOutcomeCallable CreateSpaceCallable(const CreateSpaceRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateSpace, request); } /** * An Async wrapper for CreateSpace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSpaceAsync(const CreateSpaceRequestT& request, const CreateSpaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateSpace, request, handler, context); } /** *

Creates a new Studio Lifecycle Configuration.

See Also:

AWS * API Reference

*/ virtual Model::CreateStudioLifecycleConfigOutcome CreateStudioLifecycleConfig(const Model::CreateStudioLifecycleConfigRequest& request) const; /** * A Callable wrapper for CreateStudioLifecycleConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStudioLifecycleConfigOutcomeCallable CreateStudioLifecycleConfigCallable(const CreateStudioLifecycleConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateStudioLifecycleConfig, request); } /** * An Async wrapper for CreateStudioLifecycleConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStudioLifecycleConfigAsync(const CreateStudioLifecycleConfigRequestT& request, const CreateStudioLifecycleConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateStudioLifecycleConfig, request, handler, context); } /** *

Starts a model training job. After training completes, SageMaker saves the * resulting model artifacts to an Amazon S3 location that you specify.

If * you choose to host your model using SageMaker hosting services, you can use the * resulting model artifacts as part of the model. You can also use the artifacts * in a machine learning service other than SageMaker, provided that you know how * to use them for inference.

In the request body, you provide the * following:

  • AlgorithmSpecification - Identifies * the training algorithm to use.

  • HyperParameters * - Specify these algorithm-specific parameters to enable the estimation of model * parameters during training. Hyperparameters can be tuned to optimize this * learning process. For a list of hyperparameters for each training algorithm * provided by SageMaker, see Algorithms. *

    Do not include any security-sensitive information including * account access IDs, secrets or tokens in any hyperparameter field. If the use of * security-sensitive credentials are detected, SageMaker will reject your training * job request and return an exception error.

  • * InputDataConfig - Describes the input required by the training job * and the Amazon S3, EFS, or FSx location where it is stored.

  • * OutputDataConfig - Identifies the Amazon S3 bucket where you want * SageMaker to save the results of model training.

  • * ResourceConfig - Identifies the resources, ML compute instances, * and ML storage volumes to deploy for model training. In distributed training, * you specify more than one instance.

  • * EnableManagedSpotTraining - Optimize the cost of training machine * learning models by up to 80% by using Amazon EC2 Spot instances. For more * information, see Managed * Spot Training.

  • RoleArn - The Amazon * Resource Name (ARN) that SageMaker assumes to perform tasks on your behalf * during model training. You must grant this role the necessary permissions so * that SageMaker can successfully complete model training.

  • * StoppingCondition - To help cap training costs, use * MaxRuntimeInSeconds to set a time limit for training. Use * MaxWaitTimeInSeconds to specify how long a managed spot training * job has to complete.

  • Environment - The * environment variables to set in the Docker container.

  • * RetryStrategy - The number of times to retry the job when the job * fails due to an InternalServerError.

For more * information about SageMaker, see How It * Works.

See Also:

AWS * API Reference

*/ virtual Model::CreateTrainingJobOutcome CreateTrainingJob(const Model::CreateTrainingJobRequest& request) const; /** * A Callable wrapper for CreateTrainingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrainingJobOutcomeCallable CreateTrainingJobCallable(const CreateTrainingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateTrainingJob, request); } /** * An Async wrapper for CreateTrainingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrainingJobAsync(const CreateTrainingJobRequestT& request, const CreateTrainingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateTrainingJob, request, handler, context); } /** *

Starts a transform job. A transform job uses a trained model to get * inferences on a dataset and saves these results to an Amazon S3 location that * you specify.

To perform batch transformations, you create a transform job * and use the data that you have readily available.

In the request body, * you provide the following:

  • TransformJobName - * Identifies the transform job. The name must be unique within an Amazon Web * Services Region in an Amazon Web Services account.

  • * ModelName - Identifies the model to use. ModelName * must be the name of an existing Amazon SageMaker model in the same Amazon Web * Services Region and Amazon Web Services account. For information on creating a * model, see CreateModel.

    *

  • TransformInput - Describes the dataset to be * transformed and the Amazon S3 location where it is stored.

  • * TransformOutput - Identifies the Amazon S3 location where you want * Amazon SageMaker to save the results from the transform job.

  • * TransformResources - Identifies the ML compute instances for the * transform job.

For more information about how batch * transformation works, see Batch * Transform.

See Also:

AWS * API Reference

*/ virtual Model::CreateTransformJobOutcome CreateTransformJob(const Model::CreateTransformJobRequest& request) const; /** * A Callable wrapper for CreateTransformJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTransformJobOutcomeCallable CreateTransformJobCallable(const CreateTransformJobRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateTransformJob, request); } /** * An Async wrapper for CreateTransformJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTransformJobAsync(const CreateTransformJobRequestT& request, const CreateTransformJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateTransformJob, request, handler, context); } /** *

Creates an SageMaker trial. A trial is a set of steps called trial * components that produce a machine learning model. A trial is part of a * single SageMaker experiment.

When you use SageMaker Studio or the * SageMaker Python SDK, all experiments, trials, and trial components are * automatically tracked, logged, and indexed. When you use the Amazon Web Services * SDK for Python (Boto), you must use the logging APIs provided by the SDK.

*

You can add tags to a trial and then use the Search * API to search for the tags.

To get a list of all your trials, call the ListTrials * API. To view a trial's properties, call the DescribeTrial * API. To create a trial component, call the CreateTrialComponent * API.

See Also:

AWS * API Reference

*/ virtual Model::CreateTrialOutcome CreateTrial(const Model::CreateTrialRequest& request) const; /** * A Callable wrapper for CreateTrial that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrialOutcomeCallable CreateTrialCallable(const CreateTrialRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateTrial, request); } /** * An Async wrapper for CreateTrial that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrialAsync(const CreateTrialRequestT& request, const CreateTrialResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateTrial, request, handler, context); } /** *

Creates a trial component, which is a stage of a machine learning * trial. A trial is composed of one or more trial components. A trial * component can be used in multiple trials.

Trial components include * pre-processing jobs, training jobs, and batch transform jobs.

When you * use SageMaker Studio or the SageMaker Python SDK, all experiments, trials, and * trial components are automatically tracked, logged, and indexed. When you use * the Amazon Web Services SDK for Python (Boto), you must use the logging APIs * provided by the SDK.

You can add tags to a trial component and then use * the Search * API to search for the tags.

See Also:

AWS * API Reference

*/ virtual Model::CreateTrialComponentOutcome CreateTrialComponent(const Model::CreateTrialComponentRequest& request) const; /** * A Callable wrapper for CreateTrialComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTrialComponentOutcomeCallable CreateTrialComponentCallable(const CreateTrialComponentRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateTrialComponent, request); } /** * An Async wrapper for CreateTrialComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTrialComponentAsync(const CreateTrialComponentRequestT& request, const CreateTrialComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateTrialComponent, request, handler, context); } /** *

Creates a user profile. A user profile represents a single user within a * domain, and is the main way to reference a "person" for the purposes of sharing, * reporting, and other user-oriented features. This entity is created when a user * onboards to Amazon SageMaker Studio. If an administrator invites a person by * email or imports them from IAM Identity Center, a user profile is automatically * created. A user profile is the primary holder of settings for an individual user * and has a reference to the user's private Amazon Elastic File System (EFS) home * directory.

See Also:

AWS * API Reference

*/ virtual Model::CreateUserProfileOutcome CreateUserProfile(const Model::CreateUserProfileRequest& request) const; /** * A Callable wrapper for CreateUserProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUserProfileOutcomeCallable CreateUserProfileCallable(const CreateUserProfileRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateUserProfile, request); } /** * An Async wrapper for CreateUserProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUserProfileAsync(const CreateUserProfileRequestT& request, const CreateUserProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateUserProfile, request, handler, context); } /** *

Use this operation to create a workforce. This operation will return an error * if a workforce already exists in the Amazon Web Services Region that you * specify. You can only create one workforce in each Amazon Web Services Region * per Amazon Web Services account.

If you want to create a new workforce in * an Amazon Web Services Region where a workforce already exists, use the DeleteWorkforce * API operation to delete the existing workforce and then use * CreateWorkforce to create a new workforce.

To create a * private workforce using Amazon Cognito, you must specify a Cognito user pool in * CognitoConfig. You can also create an Amazon Cognito workforce * using the Amazon SageMaker console. For more information, see * Create a Private Workforce (Amazon Cognito).

To create a private * workforce using your own OIDC Identity Provider (IdP), specify your IdP * configuration in OidcConfig. Your OIDC IdP must support * groups because groups are used by Ground Truth and Amazon A2I to create * work teams. For more information, see * Create a Private Workforce (OIDC IdP).

See Also:

AWS * API Reference

*/ virtual Model::CreateWorkforceOutcome CreateWorkforce(const Model::CreateWorkforceRequest& request) const; /** * A Callable wrapper for CreateWorkforce that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateWorkforceOutcomeCallable CreateWorkforceCallable(const CreateWorkforceRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateWorkforce, request); } /** * An Async wrapper for CreateWorkforce that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateWorkforceAsync(const CreateWorkforceRequestT& request, const CreateWorkforceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateWorkforce, request, handler, context); } /** *

Creates a new work team for labeling your data. A work team is defined by one * or more Amazon Cognito user pools. You must first create the user pools before * you can create a work team.

You cannot create more than 25 work teams in * an account and region.

See Also:

AWS * API Reference

*/ virtual Model::CreateWorkteamOutcome CreateWorkteam(const Model::CreateWorkteamRequest& request) const; /** * A Callable wrapper for CreateWorkteam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateWorkteamOutcomeCallable CreateWorkteamCallable(const CreateWorkteamRequestT& request) const { return SubmitCallable(&SageMakerClient::CreateWorkteam, request); } /** * An Async wrapper for CreateWorkteam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateWorkteamAsync(const CreateWorkteamRequestT& request, const CreateWorkteamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::CreateWorkteam, request, handler, context); } /** *

Deletes an action.

See Also:

AWS * API Reference

*/ virtual Model::DeleteActionOutcome DeleteAction(const Model::DeleteActionRequest& request) const; /** * A Callable wrapper for DeleteAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteActionOutcomeCallable DeleteActionCallable(const DeleteActionRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteAction, request); } /** * An Async wrapper for DeleteAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteActionAsync(const DeleteActionRequestT& request, const DeleteActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteAction, request, handler, context); } /** *

Removes the specified algorithm from your account.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteAlgorithmOutcome DeleteAlgorithm(const Model::DeleteAlgorithmRequest& request) const; /** * A Callable wrapper for DeleteAlgorithm that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAlgorithmOutcomeCallable DeleteAlgorithmCallable(const DeleteAlgorithmRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteAlgorithm, request); } /** * An Async wrapper for DeleteAlgorithm that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAlgorithmAsync(const DeleteAlgorithmRequestT& request, const DeleteAlgorithmResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteAlgorithm, request, handler, context); } /** *

Used to stop and delete an app.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAppOutcome DeleteApp(const Model::DeleteAppRequest& request) const; /** * A Callable wrapper for DeleteApp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAppOutcomeCallable DeleteAppCallable(const DeleteAppRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteApp, request); } /** * An Async wrapper for DeleteApp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAppAsync(const DeleteAppRequestT& request, const DeleteAppResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteApp, request, handler, context); } /** *

Deletes an AppImageConfig.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAppImageConfigOutcome DeleteAppImageConfig(const Model::DeleteAppImageConfigRequest& request) const; /** * A Callable wrapper for DeleteAppImageConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAppImageConfigOutcomeCallable DeleteAppImageConfigCallable(const DeleteAppImageConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteAppImageConfig, request); } /** * An Async wrapper for DeleteAppImageConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAppImageConfigAsync(const DeleteAppImageConfigRequestT& request, const DeleteAppImageConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteAppImageConfig, request, handler, context); } /** *

Deletes an artifact. Either ArtifactArn or Source * must be specified.

See Also:

AWS * API Reference

*/ virtual Model::DeleteArtifactOutcome DeleteArtifact(const Model::DeleteArtifactRequest& request) const; /** * A Callable wrapper for DeleteArtifact that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteArtifactOutcomeCallable DeleteArtifactCallable(const DeleteArtifactRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteArtifact, request); } /** * An Async wrapper for DeleteArtifact that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteArtifactAsync(const DeleteArtifactRequestT& request, const DeleteArtifactResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteArtifact, request, handler, context); } /** *

Deletes an association.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAssociationOutcome DeleteAssociation(const Model::DeleteAssociationRequest& request) const; /** * A Callable wrapper for DeleteAssociation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAssociationOutcomeCallable DeleteAssociationCallable(const DeleteAssociationRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteAssociation, request); } /** * An Async wrapper for DeleteAssociation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAssociationAsync(const DeleteAssociationRequestT& request, const DeleteAssociationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteAssociation, request, handler, context); } /** *

Deletes the specified Git repository from your account.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteCodeRepositoryOutcome DeleteCodeRepository(const Model::DeleteCodeRepositoryRequest& request) const; /** * A Callable wrapper for DeleteCodeRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCodeRepositoryOutcomeCallable DeleteCodeRepositoryCallable(const DeleteCodeRepositoryRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteCodeRepository, request); } /** * An Async wrapper for DeleteCodeRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCodeRepositoryAsync(const DeleteCodeRepositoryRequestT& request, const DeleteCodeRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteCodeRepository, request, handler, context); } /** *

Deletes an context.

See Also:

AWS * API Reference

*/ virtual Model::DeleteContextOutcome DeleteContext(const Model::DeleteContextRequest& request) const; /** * A Callable wrapper for DeleteContext that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteContextOutcomeCallable DeleteContextCallable(const DeleteContextRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteContext, request); } /** * An Async wrapper for DeleteContext that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteContextAsync(const DeleteContextRequestT& request, const DeleteContextResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteContext, request, handler, context); } /** *

Deletes a data quality monitoring job definition.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteDataQualityJobDefinitionOutcome DeleteDataQualityJobDefinition(const Model::DeleteDataQualityJobDefinitionRequest& request) const; /** * A Callable wrapper for DeleteDataQualityJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDataQualityJobDefinitionOutcomeCallable DeleteDataQualityJobDefinitionCallable(const DeleteDataQualityJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteDataQualityJobDefinition, request); } /** * An Async wrapper for DeleteDataQualityJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDataQualityJobDefinitionAsync(const DeleteDataQualityJobDefinitionRequestT& request, const DeleteDataQualityJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteDataQualityJobDefinition, request, handler, context); } /** *

Deletes a fleet.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDeviceFleetOutcome DeleteDeviceFleet(const Model::DeleteDeviceFleetRequest& request) const; /** * A Callable wrapper for DeleteDeviceFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDeviceFleetOutcomeCallable DeleteDeviceFleetCallable(const DeleteDeviceFleetRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteDeviceFleet, request); } /** * An Async wrapper for DeleteDeviceFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDeviceFleetAsync(const DeleteDeviceFleetRequestT& request, const DeleteDeviceFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteDeviceFleet, request, handler, context); } /** *

Used to delete a domain. If you onboarded with IAM mode, you will need to * delete your domain to onboard again using IAM Identity Center. Use with caution. * All of the members of the domain will lose access to their EFS volume, including * data, notebooks, and other artifacts.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const; /** * A Callable wrapper for DeleteDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteDomain, request); } /** * An Async wrapper for DeleteDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteDomain, request, handler, context); } /** *

Deletes an edge deployment plan if (and only if) all the stages in the plan * are inactive or there are no stages in the plan.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEdgeDeploymentPlanOutcome DeleteEdgeDeploymentPlan(const Model::DeleteEdgeDeploymentPlanRequest& request) const; /** * A Callable wrapper for DeleteEdgeDeploymentPlan that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEdgeDeploymentPlanOutcomeCallable DeleteEdgeDeploymentPlanCallable(const DeleteEdgeDeploymentPlanRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteEdgeDeploymentPlan, request); } /** * An Async wrapper for DeleteEdgeDeploymentPlan that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEdgeDeploymentPlanAsync(const DeleteEdgeDeploymentPlanRequestT& request, const DeleteEdgeDeploymentPlanResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteEdgeDeploymentPlan, request, handler, context); } /** *

Delete a stage in an edge deployment plan if (and only if) the stage is * inactive.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEdgeDeploymentStageOutcome DeleteEdgeDeploymentStage(const Model::DeleteEdgeDeploymentStageRequest& request) const; /** * A Callable wrapper for DeleteEdgeDeploymentStage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEdgeDeploymentStageOutcomeCallable DeleteEdgeDeploymentStageCallable(const DeleteEdgeDeploymentStageRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteEdgeDeploymentStage, request); } /** * An Async wrapper for DeleteEdgeDeploymentStage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEdgeDeploymentStageAsync(const DeleteEdgeDeploymentStageRequestT& request, const DeleteEdgeDeploymentStageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteEdgeDeploymentStage, request, handler, context); } /** *

Deletes an endpoint. SageMaker frees up all of the resources that were * deployed when the endpoint was created.

SageMaker retires any custom KMS * key grants associated with the endpoint, meaning you don't need to use the RevokeGrant * API call.

When you delete your endpoint, SageMaker asynchronously deletes * associated endpoint resources such as KMS key grants. You might still see these * resources in your account for a few minutes after deleting your endpoint. Do not * delete or revoke the permissions for your ExecutionRoleArn * , otherwise SageMaker cannot delete these resources.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteEndpointOutcome DeleteEndpoint(const Model::DeleteEndpointRequest& request) const; /** * A Callable wrapper for DeleteEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEndpointOutcomeCallable DeleteEndpointCallable(const DeleteEndpointRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteEndpoint, request); } /** * An Async wrapper for DeleteEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEndpointAsync(const DeleteEndpointRequestT& request, const DeleteEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteEndpoint, request, handler, context); } /** *

Deletes an endpoint configuration. The DeleteEndpointConfig API * deletes only the specified configuration. It does not delete endpoints created * using the configuration.

You must not delete an * EndpointConfig in use by an endpoint that is live or while the * UpdateEndpoint or CreateEndpoint operations are being * performed on the endpoint. If you delete the EndpointConfig of an * endpoint that is active or being created or updated you may lose visibility into * the instance type the endpoint is using. The endpoint must be deleted in order * to stop incurring charges.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEndpointConfigOutcome DeleteEndpointConfig(const Model::DeleteEndpointConfigRequest& request) const; /** * A Callable wrapper for DeleteEndpointConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEndpointConfigOutcomeCallable DeleteEndpointConfigCallable(const DeleteEndpointConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteEndpointConfig, request); } /** * An Async wrapper for DeleteEndpointConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEndpointConfigAsync(const DeleteEndpointConfigRequestT& request, const DeleteEndpointConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteEndpointConfig, request, handler, context); } /** *

Deletes an SageMaker experiment. All trials associated with the experiment * must be deleted first. Use the ListTrials * API to get a list of the trials associated with the experiment.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteExperimentOutcome DeleteExperiment(const Model::DeleteExperimentRequest& request) const; /** * A Callable wrapper for DeleteExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteExperimentOutcomeCallable DeleteExperimentCallable(const DeleteExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteExperiment, request); } /** * An Async wrapper for DeleteExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteExperimentAsync(const DeleteExperimentRequestT& request, const DeleteExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteExperiment, request, handler, context); } /** *

Delete the FeatureGroup and any data that was written to the * OnlineStore of the FeatureGroup. Data cannot be * accessed from the OnlineStore immediately after * DeleteFeatureGroup is called.

Data written into the * OfflineStore will not be deleted. The Amazon Web Services Glue * database and tables that are automatically created for your * OfflineStore are not deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFeatureGroupOutcome DeleteFeatureGroup(const Model::DeleteFeatureGroupRequest& request) const; /** * A Callable wrapper for DeleteFeatureGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFeatureGroupOutcomeCallable DeleteFeatureGroupCallable(const DeleteFeatureGroupRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteFeatureGroup, request); } /** * An Async wrapper for DeleteFeatureGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFeatureGroupAsync(const DeleteFeatureGroupRequestT& request, const DeleteFeatureGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteFeatureGroup, request, handler, context); } /** *

Deletes the specified flow definition.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFlowDefinitionOutcome DeleteFlowDefinition(const Model::DeleteFlowDefinitionRequest& request) const; /** * A Callable wrapper for DeleteFlowDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFlowDefinitionOutcomeCallable DeleteFlowDefinitionCallable(const DeleteFlowDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteFlowDefinition, request); } /** * An Async wrapper for DeleteFlowDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFlowDefinitionAsync(const DeleteFlowDefinitionRequestT& request, const DeleteFlowDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteFlowDefinition, request, handler, context); } /** *

Delete a hub.

Hub APIs are only callable through SageMaker * Studio.

See Also:

AWS * API Reference

*/ virtual Model::DeleteHubOutcome DeleteHub(const Model::DeleteHubRequest& request) const; /** * A Callable wrapper for DeleteHub that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteHubOutcomeCallable DeleteHubCallable(const DeleteHubRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteHub, request); } /** * An Async wrapper for DeleteHub that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteHubAsync(const DeleteHubRequestT& request, const DeleteHubResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteHub, request, handler, context); } /** *

Delete the contents of a hub.

Hub APIs are only callable * through SageMaker Studio.

See Also:

AWS * API Reference

*/ virtual Model::DeleteHubContentOutcome DeleteHubContent(const Model::DeleteHubContentRequest& request) const; /** * A Callable wrapper for DeleteHubContent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteHubContentOutcomeCallable DeleteHubContentCallable(const DeleteHubContentRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteHubContent, request); } /** * An Async wrapper for DeleteHubContent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteHubContentAsync(const DeleteHubContentRequestT& request, const DeleteHubContentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteHubContent, request, handler, context); } /** *

Use this operation to delete a human task user interface (worker task * template).

To see a list of human task user interfaces (work task * templates) in your account, use ListHumanTaskUis. * When you delete a worker task template, it no longer appears when you call * ListHumanTaskUis.

See Also:

AWS * API Reference

*/ virtual Model::DeleteHumanTaskUiOutcome DeleteHumanTaskUi(const Model::DeleteHumanTaskUiRequest& request) const; /** * A Callable wrapper for DeleteHumanTaskUi that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteHumanTaskUiOutcomeCallable DeleteHumanTaskUiCallable(const DeleteHumanTaskUiRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteHumanTaskUi, request); } /** * An Async wrapper for DeleteHumanTaskUi that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteHumanTaskUiAsync(const DeleteHumanTaskUiRequestT& request, const DeleteHumanTaskUiResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteHumanTaskUi, request, handler, context); } /** *

Deletes a SageMaker image and all versions of the image. The container images * aren't deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteImageOutcome DeleteImage(const Model::DeleteImageRequest& request) const; /** * A Callable wrapper for DeleteImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteImageOutcomeCallable DeleteImageCallable(const DeleteImageRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteImage, request); } /** * An Async wrapper for DeleteImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteImageAsync(const DeleteImageRequestT& request, const DeleteImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteImage, request, handler, context); } /** *

Deletes a version of a SageMaker image. The container image the version * represents isn't deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteImageVersionOutcome DeleteImageVersion(const Model::DeleteImageVersionRequest& request) const; /** * A Callable wrapper for DeleteImageVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteImageVersionOutcomeCallable DeleteImageVersionCallable(const DeleteImageVersionRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteImageVersion, request); } /** * An Async wrapper for DeleteImageVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteImageVersionAsync(const DeleteImageVersionRequestT& request, const DeleteImageVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteImageVersion, request, handler, context); } /** *

Deletes an inference experiment.

This operation does not * delete your endpoint, variants, or any underlying resources. This operation only * deletes the metadata of your experiment.

See Also:

AWS * API Reference

*/ virtual Model::DeleteInferenceExperimentOutcome DeleteInferenceExperiment(const Model::DeleteInferenceExperimentRequest& request) const; /** * A Callable wrapper for DeleteInferenceExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteInferenceExperimentOutcomeCallable DeleteInferenceExperimentCallable(const DeleteInferenceExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteInferenceExperiment, request); } /** * An Async wrapper for DeleteInferenceExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteInferenceExperimentAsync(const DeleteInferenceExperimentRequestT& request, const DeleteInferenceExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteInferenceExperiment, request, handler, context); } /** *

Deletes a model. The DeleteModel API deletes only the model * entry that was created in SageMaker when you called the CreateModel * API. It does not delete model artifacts, inference code, or the IAM role that * you specified when creating the model.

See Also:

AWS * API Reference

*/ virtual Model::DeleteModelOutcome DeleteModel(const Model::DeleteModelRequest& request) const; /** * A Callable wrapper for DeleteModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelOutcomeCallable DeleteModelCallable(const DeleteModelRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteModel, request); } /** * An Async wrapper for DeleteModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelAsync(const DeleteModelRequestT& request, const DeleteModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteModel, request, handler, context); } /** *

Deletes an Amazon SageMaker model bias job definition.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteModelBiasJobDefinitionOutcome DeleteModelBiasJobDefinition(const Model::DeleteModelBiasJobDefinitionRequest& request) const; /** * A Callable wrapper for DeleteModelBiasJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelBiasJobDefinitionOutcomeCallable DeleteModelBiasJobDefinitionCallable(const DeleteModelBiasJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteModelBiasJobDefinition, request); } /** * An Async wrapper for DeleteModelBiasJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelBiasJobDefinitionAsync(const DeleteModelBiasJobDefinitionRequestT& request, const DeleteModelBiasJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteModelBiasJobDefinition, request, handler, context); } /** *

Deletes an Amazon SageMaker Model Card.

See Also:

AWS * API Reference

*/ virtual Model::DeleteModelCardOutcome DeleteModelCard(const Model::DeleteModelCardRequest& request) const; /** * A Callable wrapper for DeleteModelCard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelCardOutcomeCallable DeleteModelCardCallable(const DeleteModelCardRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteModelCard, request); } /** * An Async wrapper for DeleteModelCard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelCardAsync(const DeleteModelCardRequestT& request, const DeleteModelCardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteModelCard, request, handler, context); } /** *

Deletes an Amazon SageMaker model explainability job * definition.

See Also:

AWS * API Reference

*/ virtual Model::DeleteModelExplainabilityJobDefinitionOutcome DeleteModelExplainabilityJobDefinition(const Model::DeleteModelExplainabilityJobDefinitionRequest& request) const; /** * A Callable wrapper for DeleteModelExplainabilityJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelExplainabilityJobDefinitionOutcomeCallable DeleteModelExplainabilityJobDefinitionCallable(const DeleteModelExplainabilityJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteModelExplainabilityJobDefinition, request); } /** * An Async wrapper for DeleteModelExplainabilityJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelExplainabilityJobDefinitionAsync(const DeleteModelExplainabilityJobDefinitionRequestT& request, const DeleteModelExplainabilityJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteModelExplainabilityJobDefinition, request, handler, context); } /** *

Deletes a model package.

A model package is used to create SageMaker * models or list on Amazon Web Services Marketplace. Buyers can subscribe to model * packages listed on Amazon Web Services Marketplace to create models in * SageMaker.

See Also:

AWS * API Reference

*/ virtual Model::DeleteModelPackageOutcome DeleteModelPackage(const Model::DeleteModelPackageRequest& request) const; /** * A Callable wrapper for DeleteModelPackage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelPackageOutcomeCallable DeleteModelPackageCallable(const DeleteModelPackageRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteModelPackage, request); } /** * An Async wrapper for DeleteModelPackage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelPackageAsync(const DeleteModelPackageRequestT& request, const DeleteModelPackageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteModelPackage, request, handler, context); } /** *

Deletes the specified model group.

See Also:

AWS * API Reference

*/ virtual Model::DeleteModelPackageGroupOutcome DeleteModelPackageGroup(const Model::DeleteModelPackageGroupRequest& request) const; /** * A Callable wrapper for DeleteModelPackageGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelPackageGroupOutcomeCallable DeleteModelPackageGroupCallable(const DeleteModelPackageGroupRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteModelPackageGroup, request); } /** * An Async wrapper for DeleteModelPackageGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelPackageGroupAsync(const DeleteModelPackageGroupRequestT& request, const DeleteModelPackageGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteModelPackageGroup, request, handler, context); } /** *

Deletes a model group resource policy.

See Also:

AWS * API Reference

*/ virtual Model::DeleteModelPackageGroupPolicyOutcome DeleteModelPackageGroupPolicy(const Model::DeleteModelPackageGroupPolicyRequest& request) const; /** * A Callable wrapper for DeleteModelPackageGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelPackageGroupPolicyOutcomeCallable DeleteModelPackageGroupPolicyCallable(const DeleteModelPackageGroupPolicyRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteModelPackageGroupPolicy, request); } /** * An Async wrapper for DeleteModelPackageGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelPackageGroupPolicyAsync(const DeleteModelPackageGroupPolicyRequestT& request, const DeleteModelPackageGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteModelPackageGroupPolicy, request, handler, context); } /** *

Deletes the secified model quality monitoring job definition.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteModelQualityJobDefinitionOutcome DeleteModelQualityJobDefinition(const Model::DeleteModelQualityJobDefinitionRequest& request) const; /** * A Callable wrapper for DeleteModelQualityJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteModelQualityJobDefinitionOutcomeCallable DeleteModelQualityJobDefinitionCallable(const DeleteModelQualityJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteModelQualityJobDefinition, request); } /** * An Async wrapper for DeleteModelQualityJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteModelQualityJobDefinitionAsync(const DeleteModelQualityJobDefinitionRequestT& request, const DeleteModelQualityJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteModelQualityJobDefinition, request, handler, context); } /** *

Deletes a monitoring schedule. Also stops the schedule had not already been * stopped. This does not delete the job execution history of the monitoring * schedule.

See Also:

AWS * API Reference

*/ virtual Model::DeleteMonitoringScheduleOutcome DeleteMonitoringSchedule(const Model::DeleteMonitoringScheduleRequest& request) const; /** * A Callable wrapper for DeleteMonitoringSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMonitoringScheduleOutcomeCallable DeleteMonitoringScheduleCallable(const DeleteMonitoringScheduleRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteMonitoringSchedule, request); } /** * An Async wrapper for DeleteMonitoringSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMonitoringScheduleAsync(const DeleteMonitoringScheduleRequestT& request, const DeleteMonitoringScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteMonitoringSchedule, request, handler, context); } /** *

Deletes an SageMaker notebook instance. Before you can delete a notebook * instance, you must call the StopNotebookInstance API.

*

When you delete a notebook instance, you lose all of your data. * SageMaker removes the ML compute instance, and deletes the ML storage volume and * the network interface associated with the notebook instance.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteNotebookInstanceOutcome DeleteNotebookInstance(const Model::DeleteNotebookInstanceRequest& request) const; /** * A Callable wrapper for DeleteNotebookInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNotebookInstanceOutcomeCallable DeleteNotebookInstanceCallable(const DeleteNotebookInstanceRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteNotebookInstance, request); } /** * An Async wrapper for DeleteNotebookInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNotebookInstanceAsync(const DeleteNotebookInstanceRequestT& request, const DeleteNotebookInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteNotebookInstance, request, handler, context); } /** *

Deletes a notebook instance lifecycle configuration.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteNotebookInstanceLifecycleConfigOutcome DeleteNotebookInstanceLifecycleConfig(const Model::DeleteNotebookInstanceLifecycleConfigRequest& request) const; /** * A Callable wrapper for DeleteNotebookInstanceLifecycleConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteNotebookInstanceLifecycleConfigOutcomeCallable DeleteNotebookInstanceLifecycleConfigCallable(const DeleteNotebookInstanceLifecycleConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteNotebookInstanceLifecycleConfig, request); } /** * An Async wrapper for DeleteNotebookInstanceLifecycleConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteNotebookInstanceLifecycleConfigAsync(const DeleteNotebookInstanceLifecycleConfigRequestT& request, const DeleteNotebookInstanceLifecycleConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteNotebookInstanceLifecycleConfig, request, handler, context); } /** *

Deletes a pipeline if there are no running instances of the pipeline. To * delete a pipeline, you must stop all running instances of the pipeline using the * StopPipelineExecution API. When you delete a pipeline, all * instances of the pipeline are deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeletePipelineOutcome DeletePipeline(const Model::DeletePipelineRequest& request) const; /** * A Callable wrapper for DeletePipeline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePipelineOutcomeCallable DeletePipelineCallable(const DeletePipelineRequestT& request) const { return SubmitCallable(&SageMakerClient::DeletePipeline, request); } /** * An Async wrapper for DeletePipeline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePipelineAsync(const DeletePipelineRequestT& request, const DeletePipelineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeletePipeline, request, handler, context); } /** *

Delete the specified project.

See Also:

AWS * API Reference

*/ virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const; /** * A Callable wrapper for DeleteProject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteProject, request); } /** * An Async wrapper for DeleteProject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteProject, request, handler, context); } /** *

Used to delete a space.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSpaceOutcome DeleteSpace(const Model::DeleteSpaceRequest& request) const; /** * A Callable wrapper for DeleteSpace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSpaceOutcomeCallable DeleteSpaceCallable(const DeleteSpaceRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteSpace, request); } /** * An Async wrapper for DeleteSpace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSpaceAsync(const DeleteSpaceRequestT& request, const DeleteSpaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteSpace, request, handler, context); } /** *

Deletes the Studio Lifecycle Configuration. In order to delete the Lifecycle * Configuration, there must be no running apps using the Lifecycle Configuration. * You must also remove the Lifecycle Configuration from UserSettings in all * Domains and UserProfiles.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStudioLifecycleConfigOutcome DeleteStudioLifecycleConfig(const Model::DeleteStudioLifecycleConfigRequest& request) const; /** * A Callable wrapper for DeleteStudioLifecycleConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStudioLifecycleConfigOutcomeCallable DeleteStudioLifecycleConfigCallable(const DeleteStudioLifecycleConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteStudioLifecycleConfig, request); } /** * An Async wrapper for DeleteStudioLifecycleConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStudioLifecycleConfigAsync(const DeleteStudioLifecycleConfigRequestT& request, const DeleteStudioLifecycleConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteStudioLifecycleConfig, request, handler, context); } /** *

Deletes the specified tags from an SageMaker resource.

To list a * resource's tags, use the ListTags API.

When you call * this API to delete tags from a hyperparameter tuning job, the deleted tags are * not removed from training jobs that the hyperparameter tuning job launched * before you called this API.

When you call this API to * delete tags from a SageMaker Studio Domain or User Profile, the deleted tags are * not removed from Apps that the SageMaker Studio Domain or User Profile launched * before you called this API.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const; /** * A Callable wrapper for DeleteTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteTags, request); } /** * An Async wrapper for DeleteTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteTags, request, handler, context); } /** *

Deletes the specified trial. All trial components that make up the trial must * be deleted first. Use the DescribeTrialComponent * API to get the list of trial components.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTrialOutcome DeleteTrial(const Model::DeleteTrialRequest& request) const; /** * A Callable wrapper for DeleteTrial that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTrialOutcomeCallable DeleteTrialCallable(const DeleteTrialRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteTrial, request); } /** * An Async wrapper for DeleteTrial that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTrialAsync(const DeleteTrialRequestT& request, const DeleteTrialResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteTrial, request, handler, context); } /** *

Deletes the specified trial component. A trial component must be * disassociated from all trials before the trial component can be deleted. To * disassociate a trial component from a trial, call the DisassociateTrialComponent * API.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTrialComponentOutcome DeleteTrialComponent(const Model::DeleteTrialComponentRequest& request) const; /** * A Callable wrapper for DeleteTrialComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTrialComponentOutcomeCallable DeleteTrialComponentCallable(const DeleteTrialComponentRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteTrialComponent, request); } /** * An Async wrapper for DeleteTrialComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTrialComponentAsync(const DeleteTrialComponentRequestT& request, const DeleteTrialComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteTrialComponent, request, handler, context); } /** *

Deletes a user profile. When a user profile is deleted, the user loses access * to their EFS volume, including data, notebooks, and other * artifacts.

See Also:

AWS * API Reference

*/ virtual Model::DeleteUserProfileOutcome DeleteUserProfile(const Model::DeleteUserProfileRequest& request) const; /** * A Callable wrapper for DeleteUserProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUserProfileOutcomeCallable DeleteUserProfileCallable(const DeleteUserProfileRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteUserProfile, request); } /** * An Async wrapper for DeleteUserProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUserProfileAsync(const DeleteUserProfileRequestT& request, const DeleteUserProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteUserProfile, request, handler, context); } /** *

Use this operation to delete a workforce.

If you want to create a new * workforce in an Amazon Web Services Region where a workforce already exists, use * this operation to delete the existing workforce and then use CreateWorkforce * to create a new workforce.

If a private workforce contains * one or more work teams, you must use the DeleteWorkteam * operation to delete all work teams before you delete the workforce. If you try * to delete a workforce that contains one or more work teams, you will recieve a * ResourceInUse error.

See Also:

AWS * API Reference

*/ virtual Model::DeleteWorkforceOutcome DeleteWorkforce(const Model::DeleteWorkforceRequest& request) const; /** * A Callable wrapper for DeleteWorkforce that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteWorkforceOutcomeCallable DeleteWorkforceCallable(const DeleteWorkforceRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteWorkforce, request); } /** * An Async wrapper for DeleteWorkforce that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteWorkforceAsync(const DeleteWorkforceRequestT& request, const DeleteWorkforceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteWorkforce, request, handler, context); } /** *

Deletes an existing work team. This operation can't be undone.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteWorkteamOutcome DeleteWorkteam(const Model::DeleteWorkteamRequest& request) const; /** * A Callable wrapper for DeleteWorkteam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteWorkteamOutcomeCallable DeleteWorkteamCallable(const DeleteWorkteamRequestT& request) const { return SubmitCallable(&SageMakerClient::DeleteWorkteam, request); } /** * An Async wrapper for DeleteWorkteam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteWorkteamAsync(const DeleteWorkteamRequestT& request, const DeleteWorkteamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeleteWorkteam, request, handler, context); } /** *

Deregisters the specified devices. After you deregister a device, you will * need to re-register the devices.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterDevicesOutcome DeregisterDevices(const Model::DeregisterDevicesRequest& request) const; /** * A Callable wrapper for DeregisterDevices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterDevicesOutcomeCallable DeregisterDevicesCallable(const DeregisterDevicesRequestT& request) const { return SubmitCallable(&SageMakerClient::DeregisterDevices, request); } /** * An Async wrapper for DeregisterDevices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterDevicesAsync(const DeregisterDevicesRequestT& request, const DeregisterDevicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DeregisterDevices, request, handler, context); } /** *

Describes an action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeActionOutcome DescribeAction(const Model::DescribeActionRequest& request) const; /** * A Callable wrapper for DescribeAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeActionOutcomeCallable DescribeActionCallable(const DescribeActionRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeAction, request); } /** * An Async wrapper for DescribeAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeActionAsync(const DescribeActionRequestT& request, const DescribeActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeAction, request, handler, context); } /** *

Returns a description of the specified algorithm that is in your * account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAlgorithmOutcome DescribeAlgorithm(const Model::DescribeAlgorithmRequest& request) const; /** * A Callable wrapper for DescribeAlgorithm that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAlgorithmOutcomeCallable DescribeAlgorithmCallable(const DescribeAlgorithmRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeAlgorithm, request); } /** * An Async wrapper for DescribeAlgorithm that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAlgorithmAsync(const DescribeAlgorithmRequestT& request, const DescribeAlgorithmResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeAlgorithm, request, handler, context); } /** *

Describes the app.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAppOutcome DescribeApp(const Model::DescribeAppRequest& request) const; /** * A Callable wrapper for DescribeApp that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAppOutcomeCallable DescribeAppCallable(const DescribeAppRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeApp, request); } /** * An Async wrapper for DescribeApp that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAppAsync(const DescribeAppRequestT& request, const DescribeAppResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeApp, request, handler, context); } /** *

Describes an AppImageConfig.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAppImageConfigOutcome DescribeAppImageConfig(const Model::DescribeAppImageConfigRequest& request) const; /** * A Callable wrapper for DescribeAppImageConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAppImageConfigOutcomeCallable DescribeAppImageConfigCallable(const DescribeAppImageConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeAppImageConfig, request); } /** * An Async wrapper for DescribeAppImageConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAppImageConfigAsync(const DescribeAppImageConfigRequestT& request, const DescribeAppImageConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeAppImageConfig, request, handler, context); } /** *

Describes an artifact.

See Also:

AWS * API Reference

*/ virtual Model::DescribeArtifactOutcome DescribeArtifact(const Model::DescribeArtifactRequest& request) const; /** * A Callable wrapper for DescribeArtifact that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeArtifactOutcomeCallable DescribeArtifactCallable(const DescribeArtifactRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeArtifact, request); } /** * An Async wrapper for DescribeArtifact that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeArtifactAsync(const DescribeArtifactRequestT& request, const DescribeArtifactResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeArtifact, request, handler, context); } /** *

Returns information about an AutoML job created by calling CreateAutoMLJob.

*

AutoML jobs created by calling CreateAutoMLJobV2 * cannot be described by DescribeAutoMLJob.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAutoMLJobOutcome DescribeAutoMLJob(const Model::DescribeAutoMLJobRequest& request) const; /** * A Callable wrapper for DescribeAutoMLJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAutoMLJobOutcomeCallable DescribeAutoMLJobCallable(const DescribeAutoMLJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeAutoMLJob, request); } /** * An Async wrapper for DescribeAutoMLJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAutoMLJobAsync(const DescribeAutoMLJobRequestT& request, const DescribeAutoMLJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeAutoMLJob, request, handler, context); } /** *

Returns information about an AutoML job created by calling CreateAutoMLJobV2 * or CreateAutoMLJob.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAutoMLJobV2Outcome DescribeAutoMLJobV2(const Model::DescribeAutoMLJobV2Request& request) const; /** * A Callable wrapper for DescribeAutoMLJobV2 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAutoMLJobV2OutcomeCallable DescribeAutoMLJobV2Callable(const DescribeAutoMLJobV2RequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeAutoMLJobV2, request); } /** * An Async wrapper for DescribeAutoMLJobV2 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAutoMLJobV2Async(const DescribeAutoMLJobV2RequestT& request, const DescribeAutoMLJobV2ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeAutoMLJobV2, request, handler, context); } /** *

Gets details about the specified Git repository.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeCodeRepositoryOutcome DescribeCodeRepository(const Model::DescribeCodeRepositoryRequest& request) const; /** * A Callable wrapper for DescribeCodeRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCodeRepositoryOutcomeCallable DescribeCodeRepositoryCallable(const DescribeCodeRepositoryRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeCodeRepository, request); } /** * An Async wrapper for DescribeCodeRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCodeRepositoryAsync(const DescribeCodeRepositoryRequestT& request, const DescribeCodeRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeCodeRepository, request, handler, context); } /** *

Returns information about a model compilation job.

To create a model * compilation job, use CreateCompilationJob. * To get information about multiple model compilation jobs, use ListCompilationJobs.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeCompilationJobOutcome DescribeCompilationJob(const Model::DescribeCompilationJobRequest& request) const; /** * A Callable wrapper for DescribeCompilationJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCompilationJobOutcomeCallable DescribeCompilationJobCallable(const DescribeCompilationJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeCompilationJob, request); } /** * An Async wrapper for DescribeCompilationJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCompilationJobAsync(const DescribeCompilationJobRequestT& request, const DescribeCompilationJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeCompilationJob, request, handler, context); } /** *

Describes a context.

See Also:

AWS * API Reference

*/ virtual Model::DescribeContextOutcome DescribeContext(const Model::DescribeContextRequest& request) const; /** * A Callable wrapper for DescribeContext that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeContextOutcomeCallable DescribeContextCallable(const DescribeContextRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeContext, request); } /** * An Async wrapper for DescribeContext that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeContextAsync(const DescribeContextRequestT& request, const DescribeContextResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeContext, request, handler, context); } /** *

Gets the details of a data quality monitoring job definition.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeDataQualityJobDefinitionOutcome DescribeDataQualityJobDefinition(const Model::DescribeDataQualityJobDefinitionRequest& request) const; /** * A Callable wrapper for DescribeDataQualityJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDataQualityJobDefinitionOutcomeCallable DescribeDataQualityJobDefinitionCallable(const DescribeDataQualityJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeDataQualityJobDefinition, request); } /** * An Async wrapper for DescribeDataQualityJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDataQualityJobDefinitionAsync(const DescribeDataQualityJobDefinitionRequestT& request, const DescribeDataQualityJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeDataQualityJobDefinition, request, handler, context); } /** *

Describes the device.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDeviceOutcome DescribeDevice(const Model::DescribeDeviceRequest& request) const; /** * A Callable wrapper for DescribeDevice that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDeviceOutcomeCallable DescribeDeviceCallable(const DescribeDeviceRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeDevice, request); } /** * An Async wrapper for DescribeDevice that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDeviceAsync(const DescribeDeviceRequestT& request, const DescribeDeviceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeDevice, request, handler, context); } /** *

A description of the fleet the device belongs to.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeDeviceFleetOutcome DescribeDeviceFleet(const Model::DescribeDeviceFleetRequest& request) const; /** * A Callable wrapper for DescribeDeviceFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDeviceFleetOutcomeCallable DescribeDeviceFleetCallable(const DescribeDeviceFleetRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeDeviceFleet, request); } /** * An Async wrapper for DescribeDeviceFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDeviceFleetAsync(const DescribeDeviceFleetRequestT& request, const DescribeDeviceFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeDeviceFleet, request, handler, context); } /** *

The description of the domain.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDomainOutcome DescribeDomain(const Model::DescribeDomainRequest& request) const; /** * A Callable wrapper for DescribeDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDomainOutcomeCallable DescribeDomainCallable(const DescribeDomainRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeDomain, request); } /** * An Async wrapper for DescribeDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDomainAsync(const DescribeDomainRequestT& request, const DescribeDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeDomain, request, handler, context); } /** *

Describes an edge deployment plan with deployment status per * stage.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEdgeDeploymentPlanOutcome DescribeEdgeDeploymentPlan(const Model::DescribeEdgeDeploymentPlanRequest& request) const; /** * A Callable wrapper for DescribeEdgeDeploymentPlan that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEdgeDeploymentPlanOutcomeCallable DescribeEdgeDeploymentPlanCallable(const DescribeEdgeDeploymentPlanRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeEdgeDeploymentPlan, request); } /** * An Async wrapper for DescribeEdgeDeploymentPlan that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEdgeDeploymentPlanAsync(const DescribeEdgeDeploymentPlanRequestT& request, const DescribeEdgeDeploymentPlanResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeEdgeDeploymentPlan, request, handler, context); } /** *

A description of edge packaging jobs.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEdgePackagingJobOutcome DescribeEdgePackagingJob(const Model::DescribeEdgePackagingJobRequest& request) const; /** * A Callable wrapper for DescribeEdgePackagingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEdgePackagingJobOutcomeCallable DescribeEdgePackagingJobCallable(const DescribeEdgePackagingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeEdgePackagingJob, request); } /** * An Async wrapper for DescribeEdgePackagingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEdgePackagingJobAsync(const DescribeEdgePackagingJobRequestT& request, const DescribeEdgePackagingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeEdgePackagingJob, request, handler, context); } /** *

Returns the description of an endpoint.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEndpointOutcome DescribeEndpoint(const Model::DescribeEndpointRequest& request) const; /** * A Callable wrapper for DescribeEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEndpointOutcomeCallable DescribeEndpointCallable(const DescribeEndpointRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeEndpoint, request); } /** * An Async wrapper for DescribeEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEndpointAsync(const DescribeEndpointRequestT& request, const DescribeEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeEndpoint, request, handler, context); } /** *

Returns the description of an endpoint configuration created using the * CreateEndpointConfig API.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEndpointConfigOutcome DescribeEndpointConfig(const Model::DescribeEndpointConfigRequest& request) const; /** * A Callable wrapper for DescribeEndpointConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEndpointConfigOutcomeCallable DescribeEndpointConfigCallable(const DescribeEndpointConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeEndpointConfig, request); } /** * An Async wrapper for DescribeEndpointConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEndpointConfigAsync(const DescribeEndpointConfigRequestT& request, const DescribeEndpointConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeEndpointConfig, request, handler, context); } /** *

Provides a list of an experiment's properties.

See Also:

AWS * API Reference

*/ virtual Model::DescribeExperimentOutcome DescribeExperiment(const Model::DescribeExperimentRequest& request) const; /** * A Callable wrapper for DescribeExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeExperimentOutcomeCallable DescribeExperimentCallable(const DescribeExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeExperiment, request); } /** * An Async wrapper for DescribeExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeExperimentAsync(const DescribeExperimentRequestT& request, const DescribeExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeExperiment, request, handler, context); } /** *

Use this operation to describe a FeatureGroup. The response * includes information on the creation time, FeatureGroup name, the * unique identifier for each FeatureGroup, and more.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeFeatureGroupOutcome DescribeFeatureGroup(const Model::DescribeFeatureGroupRequest& request) const; /** * A Callable wrapper for DescribeFeatureGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFeatureGroupOutcomeCallable DescribeFeatureGroupCallable(const DescribeFeatureGroupRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeFeatureGroup, request); } /** * An Async wrapper for DescribeFeatureGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFeatureGroupAsync(const DescribeFeatureGroupRequestT& request, const DescribeFeatureGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeFeatureGroup, request, handler, context); } /** *

Shows the metadata for a feature within a feature group.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeFeatureMetadataOutcome DescribeFeatureMetadata(const Model::DescribeFeatureMetadataRequest& request) const; /** * A Callable wrapper for DescribeFeatureMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFeatureMetadataOutcomeCallable DescribeFeatureMetadataCallable(const DescribeFeatureMetadataRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeFeatureMetadata, request); } /** * An Async wrapper for DescribeFeatureMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFeatureMetadataAsync(const DescribeFeatureMetadataRequestT& request, const DescribeFeatureMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeFeatureMetadata, request, handler, context); } /** *

Returns information about the specified flow definition.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeFlowDefinitionOutcome DescribeFlowDefinition(const Model::DescribeFlowDefinitionRequest& request) const; /** * A Callable wrapper for DescribeFlowDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFlowDefinitionOutcomeCallable DescribeFlowDefinitionCallable(const DescribeFlowDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeFlowDefinition, request); } /** * An Async wrapper for DescribeFlowDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFlowDefinitionAsync(const DescribeFlowDefinitionRequestT& request, const DescribeFlowDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeFlowDefinition, request, handler, context); } /** *

Describe a hub.

Hub APIs are only callable through SageMaker * Studio.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHubOutcome DescribeHub(const Model::DescribeHubRequest& request) const; /** * A Callable wrapper for DescribeHub that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHubOutcomeCallable DescribeHubCallable(const DescribeHubRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeHub, request); } /** * An Async wrapper for DescribeHub that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHubAsync(const DescribeHubRequestT& request, const DescribeHubResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeHub, request, handler, context); } /** *

Describe the content of a hub.

Hub APIs are only callable * through SageMaker Studio.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHubContentOutcome DescribeHubContent(const Model::DescribeHubContentRequest& request) const; /** * A Callable wrapper for DescribeHubContent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHubContentOutcomeCallable DescribeHubContentCallable(const DescribeHubContentRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeHubContent, request); } /** * An Async wrapper for DescribeHubContent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHubContentAsync(const DescribeHubContentRequestT& request, const DescribeHubContentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeHubContent, request, handler, context); } /** *

Returns information about the requested human task user interface (worker * task template).

See Also:

AWS * API Reference

*/ virtual Model::DescribeHumanTaskUiOutcome DescribeHumanTaskUi(const Model::DescribeHumanTaskUiRequest& request) const; /** * A Callable wrapper for DescribeHumanTaskUi that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHumanTaskUiOutcomeCallable DescribeHumanTaskUiCallable(const DescribeHumanTaskUiRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeHumanTaskUi, request); } /** * An Async wrapper for DescribeHumanTaskUi that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHumanTaskUiAsync(const DescribeHumanTaskUiRequestT& request, const DescribeHumanTaskUiResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeHumanTaskUi, request, handler, context); } /** *

Returns a description of a hyperparameter tuning job, depending on the fields * selected. These fields can include the name, Amazon Resource Name (ARN), job * status of your tuning job and more.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHyperParameterTuningJobOutcome DescribeHyperParameterTuningJob(const Model::DescribeHyperParameterTuningJobRequest& request) const; /** * A Callable wrapper for DescribeHyperParameterTuningJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHyperParameterTuningJobOutcomeCallable DescribeHyperParameterTuningJobCallable(const DescribeHyperParameterTuningJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeHyperParameterTuningJob, request); } /** * An Async wrapper for DescribeHyperParameterTuningJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHyperParameterTuningJobAsync(const DescribeHyperParameterTuningJobRequestT& request, const DescribeHyperParameterTuningJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeHyperParameterTuningJob, request, handler, context); } /** *

Describes a SageMaker image.

See Also:

AWS * API Reference

*/ virtual Model::DescribeImageOutcome DescribeImage(const Model::DescribeImageRequest& request) const; /** * A Callable wrapper for DescribeImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImageOutcomeCallable DescribeImageCallable(const DescribeImageRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeImage, request); } /** * An Async wrapper for DescribeImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImageAsync(const DescribeImageRequestT& request, const DescribeImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeImage, request, handler, context); } /** *

Describes a version of a SageMaker image.

See Also:

AWS * API Reference

*/ virtual Model::DescribeImageVersionOutcome DescribeImageVersion(const Model::DescribeImageVersionRequest& request) const; /** * A Callable wrapper for DescribeImageVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImageVersionOutcomeCallable DescribeImageVersionCallable(const DescribeImageVersionRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeImageVersion, request); } /** * An Async wrapper for DescribeImageVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImageVersionAsync(const DescribeImageVersionRequestT& request, const DescribeImageVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeImageVersion, request, handler, context); } /** *

Returns details about an inference experiment.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInferenceExperimentOutcome DescribeInferenceExperiment(const Model::DescribeInferenceExperimentRequest& request) const; /** * A Callable wrapper for DescribeInferenceExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInferenceExperimentOutcomeCallable DescribeInferenceExperimentCallable(const DescribeInferenceExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeInferenceExperiment, request); } /** * An Async wrapper for DescribeInferenceExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInferenceExperimentAsync(const DescribeInferenceExperimentRequestT& request, const DescribeInferenceExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeInferenceExperiment, request, handler, context); } /** *

Provides the results of the Inference Recommender job. One or more * recommendation jobs are returned.

See Also:

AWS * API Reference

*/ virtual Model::DescribeInferenceRecommendationsJobOutcome DescribeInferenceRecommendationsJob(const Model::DescribeInferenceRecommendationsJobRequest& request) const; /** * A Callable wrapper for DescribeInferenceRecommendationsJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeInferenceRecommendationsJobOutcomeCallable DescribeInferenceRecommendationsJobCallable(const DescribeInferenceRecommendationsJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeInferenceRecommendationsJob, request); } /** * An Async wrapper for DescribeInferenceRecommendationsJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeInferenceRecommendationsJobAsync(const DescribeInferenceRecommendationsJobRequestT& request, const DescribeInferenceRecommendationsJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeInferenceRecommendationsJob, request, handler, context); } /** *

Gets information about a labeling job.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLabelingJobOutcome DescribeLabelingJob(const Model::DescribeLabelingJobRequest& request) const; /** * A Callable wrapper for DescribeLabelingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLabelingJobOutcomeCallable DescribeLabelingJobCallable(const DescribeLabelingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeLabelingJob, request); } /** * An Async wrapper for DescribeLabelingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLabelingJobAsync(const DescribeLabelingJobRequestT& request, const DescribeLabelingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeLabelingJob, request, handler, context); } /** *

Provides a list of properties for the requested lineage group. For more * information, see * Cross-Account Lineage Tracking in the Amazon SageMaker Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeLineageGroupOutcome DescribeLineageGroup(const Model::DescribeLineageGroupRequest& request) const; /** * A Callable wrapper for DescribeLineageGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeLineageGroupOutcomeCallable DescribeLineageGroupCallable(const DescribeLineageGroupRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeLineageGroup, request); } /** * An Async wrapper for DescribeLineageGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeLineageGroupAsync(const DescribeLineageGroupRequestT& request, const DescribeLineageGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeLineageGroup, request, handler, context); } /** *

Describes a model that you created using the CreateModel * API.

See Also:

AWS * API Reference

*/ virtual Model::DescribeModelOutcome DescribeModel(const Model::DescribeModelRequest& request) const; /** * A Callable wrapper for DescribeModel that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeModelOutcomeCallable DescribeModelCallable(const DescribeModelRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeModel, request); } /** * An Async wrapper for DescribeModel that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeModelAsync(const DescribeModelRequestT& request, const DescribeModelResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeModel, request, handler, context); } /** *

Returns a description of a model bias job definition.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeModelBiasJobDefinitionOutcome DescribeModelBiasJobDefinition(const Model::DescribeModelBiasJobDefinitionRequest& request) const; /** * A Callable wrapper for DescribeModelBiasJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeModelBiasJobDefinitionOutcomeCallable DescribeModelBiasJobDefinitionCallable(const DescribeModelBiasJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeModelBiasJobDefinition, request); } /** * An Async wrapper for DescribeModelBiasJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeModelBiasJobDefinitionAsync(const DescribeModelBiasJobDefinitionRequestT& request, const DescribeModelBiasJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeModelBiasJobDefinition, request, handler, context); } /** *

Describes the content, creation time, and security configuration of an Amazon * SageMaker Model Card.

See Also:

AWS * API Reference

*/ virtual Model::DescribeModelCardOutcome DescribeModelCard(const Model::DescribeModelCardRequest& request) const; /** * A Callable wrapper for DescribeModelCard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeModelCardOutcomeCallable DescribeModelCardCallable(const DescribeModelCardRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeModelCard, request); } /** * An Async wrapper for DescribeModelCard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeModelCardAsync(const DescribeModelCardRequestT& request, const DescribeModelCardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeModelCard, request, handler, context); } /** *

Describes an Amazon SageMaker Model Card export job.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeModelCardExportJobOutcome DescribeModelCardExportJob(const Model::DescribeModelCardExportJobRequest& request) const; /** * A Callable wrapper for DescribeModelCardExportJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeModelCardExportJobOutcomeCallable DescribeModelCardExportJobCallable(const DescribeModelCardExportJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeModelCardExportJob, request); } /** * An Async wrapper for DescribeModelCardExportJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeModelCardExportJobAsync(const DescribeModelCardExportJobRequestT& request, const DescribeModelCardExportJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeModelCardExportJob, request, handler, context); } /** *

Returns a description of a model explainability job definition.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeModelExplainabilityJobDefinitionOutcome DescribeModelExplainabilityJobDefinition(const Model::DescribeModelExplainabilityJobDefinitionRequest& request) const; /** * A Callable wrapper for DescribeModelExplainabilityJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeModelExplainabilityJobDefinitionOutcomeCallable DescribeModelExplainabilityJobDefinitionCallable(const DescribeModelExplainabilityJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeModelExplainabilityJobDefinition, request); } /** * An Async wrapper for DescribeModelExplainabilityJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeModelExplainabilityJobDefinitionAsync(const DescribeModelExplainabilityJobDefinitionRequestT& request, const DescribeModelExplainabilityJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeModelExplainabilityJobDefinition, request, handler, context); } /** *

Returns a description of the specified model package, which is used to create * SageMaker models or list them on Amazon Web Services Marketplace.

To * create models in SageMaker, buyers can subscribe to model packages listed on * Amazon Web Services Marketplace.

See Also:

AWS * API Reference

*/ virtual Model::DescribeModelPackageOutcome DescribeModelPackage(const Model::DescribeModelPackageRequest& request) const; /** * A Callable wrapper for DescribeModelPackage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeModelPackageOutcomeCallable DescribeModelPackageCallable(const DescribeModelPackageRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeModelPackage, request); } /** * An Async wrapper for DescribeModelPackage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeModelPackageAsync(const DescribeModelPackageRequestT& request, const DescribeModelPackageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeModelPackage, request, handler, context); } /** *

Gets a description for the specified model group.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeModelPackageGroupOutcome DescribeModelPackageGroup(const Model::DescribeModelPackageGroupRequest& request) const; /** * A Callable wrapper for DescribeModelPackageGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeModelPackageGroupOutcomeCallable DescribeModelPackageGroupCallable(const DescribeModelPackageGroupRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeModelPackageGroup, request); } /** * An Async wrapper for DescribeModelPackageGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeModelPackageGroupAsync(const DescribeModelPackageGroupRequestT& request, const DescribeModelPackageGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeModelPackageGroup, request, handler, context); } /** *

Returns a description of a model quality job definition.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeModelQualityJobDefinitionOutcome DescribeModelQualityJobDefinition(const Model::DescribeModelQualityJobDefinitionRequest& request) const; /** * A Callable wrapper for DescribeModelQualityJobDefinition that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeModelQualityJobDefinitionOutcomeCallable DescribeModelQualityJobDefinitionCallable(const DescribeModelQualityJobDefinitionRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeModelQualityJobDefinition, request); } /** * An Async wrapper for DescribeModelQualityJobDefinition that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeModelQualityJobDefinitionAsync(const DescribeModelQualityJobDefinitionRequestT& request, const DescribeModelQualityJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeModelQualityJobDefinition, request, handler, context); } /** *

Describes the schedule for a monitoring job.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMonitoringScheduleOutcome DescribeMonitoringSchedule(const Model::DescribeMonitoringScheduleRequest& request) const; /** * A Callable wrapper for DescribeMonitoringSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMonitoringScheduleOutcomeCallable DescribeMonitoringScheduleCallable(const DescribeMonitoringScheduleRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeMonitoringSchedule, request); } /** * An Async wrapper for DescribeMonitoringSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMonitoringScheduleAsync(const DescribeMonitoringScheduleRequestT& request, const DescribeMonitoringScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeMonitoringSchedule, request, handler, context); } /** *

Returns information about a notebook instance.

See Also:

AWS * API Reference

*/ virtual Model::DescribeNotebookInstanceOutcome DescribeNotebookInstance(const Model::DescribeNotebookInstanceRequest& request) const; /** * A Callable wrapper for DescribeNotebookInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNotebookInstanceOutcomeCallable DescribeNotebookInstanceCallable(const DescribeNotebookInstanceRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeNotebookInstance, request); } /** * An Async wrapper for DescribeNotebookInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNotebookInstanceAsync(const DescribeNotebookInstanceRequestT& request, const DescribeNotebookInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeNotebookInstance, request, handler, context); } /** *

Returns a description of a notebook instance lifecycle configuration.

*

For information about notebook instance lifestyle configurations, see Step * 2.1: (Optional) Customize a Notebook Instance.

See Also:

AWS * API Reference

*/ virtual Model::DescribeNotebookInstanceLifecycleConfigOutcome DescribeNotebookInstanceLifecycleConfig(const Model::DescribeNotebookInstanceLifecycleConfigRequest& request) const; /** * A Callable wrapper for DescribeNotebookInstanceLifecycleConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeNotebookInstanceLifecycleConfigOutcomeCallable DescribeNotebookInstanceLifecycleConfigCallable(const DescribeNotebookInstanceLifecycleConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeNotebookInstanceLifecycleConfig, request); } /** * An Async wrapper for DescribeNotebookInstanceLifecycleConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeNotebookInstanceLifecycleConfigAsync(const DescribeNotebookInstanceLifecycleConfigRequestT& request, const DescribeNotebookInstanceLifecycleConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeNotebookInstanceLifecycleConfig, request, handler, context); } /** *

Describes the details of a pipeline.

See Also:

AWS * API Reference

*/ virtual Model::DescribePipelineOutcome DescribePipeline(const Model::DescribePipelineRequest& request) const; /** * A Callable wrapper for DescribePipeline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePipelineOutcomeCallable DescribePipelineCallable(const DescribePipelineRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribePipeline, request); } /** * An Async wrapper for DescribePipeline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePipelineAsync(const DescribePipelineRequestT& request, const DescribePipelineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribePipeline, request, handler, context); } /** *

Describes the details of an execution's pipeline definition.

See * Also:

AWS * API Reference

*/ virtual Model::DescribePipelineDefinitionForExecutionOutcome DescribePipelineDefinitionForExecution(const Model::DescribePipelineDefinitionForExecutionRequest& request) const; /** * A Callable wrapper for DescribePipelineDefinitionForExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePipelineDefinitionForExecutionOutcomeCallable DescribePipelineDefinitionForExecutionCallable(const DescribePipelineDefinitionForExecutionRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribePipelineDefinitionForExecution, request); } /** * An Async wrapper for DescribePipelineDefinitionForExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePipelineDefinitionForExecutionAsync(const DescribePipelineDefinitionForExecutionRequestT& request, const DescribePipelineDefinitionForExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribePipelineDefinitionForExecution, request, handler, context); } /** *

Describes the details of a pipeline execution.

See Also:

AWS * API Reference

*/ virtual Model::DescribePipelineExecutionOutcome DescribePipelineExecution(const Model::DescribePipelineExecutionRequest& request) const; /** * A Callable wrapper for DescribePipelineExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePipelineExecutionOutcomeCallable DescribePipelineExecutionCallable(const DescribePipelineExecutionRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribePipelineExecution, request); } /** * An Async wrapper for DescribePipelineExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePipelineExecutionAsync(const DescribePipelineExecutionRequestT& request, const DescribePipelineExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribePipelineExecution, request, handler, context); } /** *

Returns a description of a processing job.

See Also:

AWS * API Reference

*/ virtual Model::DescribeProcessingJobOutcome DescribeProcessingJob(const Model::DescribeProcessingJobRequest& request) const; /** * A Callable wrapper for DescribeProcessingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeProcessingJobOutcomeCallable DescribeProcessingJobCallable(const DescribeProcessingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeProcessingJob, request); } /** * An Async wrapper for DescribeProcessingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeProcessingJobAsync(const DescribeProcessingJobRequestT& request, const DescribeProcessingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeProcessingJob, request, handler, context); } /** *

Describes the details of a project.

See Also:

AWS * API Reference

*/ virtual Model::DescribeProjectOutcome DescribeProject(const Model::DescribeProjectRequest& request) const; /** * A Callable wrapper for DescribeProject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeProjectOutcomeCallable DescribeProjectCallable(const DescribeProjectRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeProject, request); } /** * An Async wrapper for DescribeProject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeProjectAsync(const DescribeProjectRequestT& request, const DescribeProjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeProject, request, handler, context); } /** *

Describes the space.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSpaceOutcome DescribeSpace(const Model::DescribeSpaceRequest& request) const; /** * A Callable wrapper for DescribeSpace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSpaceOutcomeCallable DescribeSpaceCallable(const DescribeSpaceRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeSpace, request); } /** * An Async wrapper for DescribeSpace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSpaceAsync(const DescribeSpaceRequestT& request, const DescribeSpaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeSpace, request, handler, context); } /** *

Describes the Studio Lifecycle Configuration.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStudioLifecycleConfigOutcome DescribeStudioLifecycleConfig(const Model::DescribeStudioLifecycleConfigRequest& request) const; /** * A Callable wrapper for DescribeStudioLifecycleConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStudioLifecycleConfigOutcomeCallable DescribeStudioLifecycleConfigCallable(const DescribeStudioLifecycleConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeStudioLifecycleConfig, request); } /** * An Async wrapper for DescribeStudioLifecycleConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStudioLifecycleConfigAsync(const DescribeStudioLifecycleConfigRequestT& request, const DescribeStudioLifecycleConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeStudioLifecycleConfig, request, handler, context); } /** *

Gets information about a work team provided by a vendor. It returns details * about the subscription with a vendor in the Amazon Web Services * Marketplace.

See Also:

AWS * API Reference

*/ virtual Model::DescribeSubscribedWorkteamOutcome DescribeSubscribedWorkteam(const Model::DescribeSubscribedWorkteamRequest& request) const; /** * A Callable wrapper for DescribeSubscribedWorkteam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSubscribedWorkteamOutcomeCallable DescribeSubscribedWorkteamCallable(const DescribeSubscribedWorkteamRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeSubscribedWorkteam, request); } /** * An Async wrapper for DescribeSubscribedWorkteam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSubscribedWorkteamAsync(const DescribeSubscribedWorkteamRequestT& request, const DescribeSubscribedWorkteamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeSubscribedWorkteam, request, handler, context); } /** *

Returns information about a training job.

Some of the attributes * below only appear if the training job successfully starts. If the training job * fails, TrainingJobStatus is Failed and, depending on * the FailureReason, attributes like TrainingStartTime, * TrainingTimeInSeconds, TrainingEndTime, and * BillableTimeInSeconds may not be present in the * response.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTrainingJobOutcome DescribeTrainingJob(const Model::DescribeTrainingJobRequest& request) const; /** * A Callable wrapper for DescribeTrainingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTrainingJobOutcomeCallable DescribeTrainingJobCallable(const DescribeTrainingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeTrainingJob, request); } /** * An Async wrapper for DescribeTrainingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTrainingJobAsync(const DescribeTrainingJobRequestT& request, const DescribeTrainingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeTrainingJob, request, handler, context); } /** *

Returns information about a transform job.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTransformJobOutcome DescribeTransformJob(const Model::DescribeTransformJobRequest& request) const; /** * A Callable wrapper for DescribeTransformJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTransformJobOutcomeCallable DescribeTransformJobCallable(const DescribeTransformJobRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeTransformJob, request); } /** * An Async wrapper for DescribeTransformJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTransformJobAsync(const DescribeTransformJobRequestT& request, const DescribeTransformJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeTransformJob, request, handler, context); } /** *

Provides a list of a trial's properties.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTrialOutcome DescribeTrial(const Model::DescribeTrialRequest& request) const; /** * A Callable wrapper for DescribeTrial that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTrialOutcomeCallable DescribeTrialCallable(const DescribeTrialRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeTrial, request); } /** * An Async wrapper for DescribeTrial that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTrialAsync(const DescribeTrialRequestT& request, const DescribeTrialResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeTrial, request, handler, context); } /** *

Provides a list of a trials component's properties.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeTrialComponentOutcome DescribeTrialComponent(const Model::DescribeTrialComponentRequest& request) const; /** * A Callable wrapper for DescribeTrialComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTrialComponentOutcomeCallable DescribeTrialComponentCallable(const DescribeTrialComponentRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeTrialComponent, request); } /** * An Async wrapper for DescribeTrialComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTrialComponentAsync(const DescribeTrialComponentRequestT& request, const DescribeTrialComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeTrialComponent, request, handler, context); } /** *

Describes a user profile. For more information, see * CreateUserProfile.

See Also:

AWS * API Reference

*/ virtual Model::DescribeUserProfileOutcome DescribeUserProfile(const Model::DescribeUserProfileRequest& request) const; /** * A Callable wrapper for DescribeUserProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUserProfileOutcomeCallable DescribeUserProfileCallable(const DescribeUserProfileRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeUserProfile, request); } /** * An Async wrapper for DescribeUserProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUserProfileAsync(const DescribeUserProfileRequestT& request, const DescribeUserProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeUserProfile, request, handler, context); } /** *

Lists private workforce information, including workforce name, Amazon * Resource Name (ARN), and, if applicable, allowed IP address ranges (CIDRs). * Allowable IP address ranges are the IP addresses that workers can use to access * tasks.

This operation applies only to private * workforces.

See Also:

AWS * API Reference

*/ virtual Model::DescribeWorkforceOutcome DescribeWorkforce(const Model::DescribeWorkforceRequest& request) const; /** * A Callable wrapper for DescribeWorkforce that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeWorkforceOutcomeCallable DescribeWorkforceCallable(const DescribeWorkforceRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeWorkforce, request); } /** * An Async wrapper for DescribeWorkforce that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeWorkforceAsync(const DescribeWorkforceRequestT& request, const DescribeWorkforceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeWorkforce, request, handler, context); } /** *

Gets information about a specific work team. You can see information such as * the create date, the last updated date, membership information, and the work * team's Amazon Resource Name (ARN).

See Also:

AWS * API Reference

*/ virtual Model::DescribeWorkteamOutcome DescribeWorkteam(const Model::DescribeWorkteamRequest& request) const; /** * A Callable wrapper for DescribeWorkteam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeWorkteamOutcomeCallable DescribeWorkteamCallable(const DescribeWorkteamRequestT& request) const { return SubmitCallable(&SageMakerClient::DescribeWorkteam, request); } /** * An Async wrapper for DescribeWorkteam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeWorkteamAsync(const DescribeWorkteamRequestT& request, const DescribeWorkteamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DescribeWorkteam, request, handler, context); } /** *

Disables using Service Catalog in SageMaker. Service Catalog is used to * create SageMaker projects.

See Also:

AWS * API Reference

*/ virtual Model::DisableSagemakerServicecatalogPortfolioOutcome DisableSagemakerServicecatalogPortfolio(const Model::DisableSagemakerServicecatalogPortfolioRequest& request) const; /** * A Callable wrapper for DisableSagemakerServicecatalogPortfolio that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableSagemakerServicecatalogPortfolioOutcomeCallable DisableSagemakerServicecatalogPortfolioCallable(const DisableSagemakerServicecatalogPortfolioRequestT& request) const { return SubmitCallable(&SageMakerClient::DisableSagemakerServicecatalogPortfolio, request); } /** * An Async wrapper for DisableSagemakerServicecatalogPortfolio that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableSagemakerServicecatalogPortfolioAsync(const DisableSagemakerServicecatalogPortfolioRequestT& request, const DisableSagemakerServicecatalogPortfolioResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DisableSagemakerServicecatalogPortfolio, request, handler, context); } /** *

Disassociates a trial component from a trial. This doesn't effect other * trials the component is associated with. Before you can delete a component, you * must disassociate the component from all trials it is associated with. To * associate a trial component with a trial, call the AssociateTrialComponent * API.

To get a list of the trials a component is associated with, use the * Search * API. Specify ExperimentTrialComponent for the Resource * parameter. The list appears in the response under * Results.TrialComponent.Parents.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateTrialComponentOutcome DisassociateTrialComponent(const Model::DisassociateTrialComponentRequest& request) const; /** * A Callable wrapper for DisassociateTrialComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateTrialComponentOutcomeCallable DisassociateTrialComponentCallable(const DisassociateTrialComponentRequestT& request) const { return SubmitCallable(&SageMakerClient::DisassociateTrialComponent, request); } /** * An Async wrapper for DisassociateTrialComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateTrialComponentAsync(const DisassociateTrialComponentRequestT& request, const DisassociateTrialComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::DisassociateTrialComponent, request, handler, context); } /** *

Enables using Service Catalog in SageMaker. Service Catalog is used to create * SageMaker projects.

See Also:

AWS * API Reference

*/ virtual Model::EnableSagemakerServicecatalogPortfolioOutcome EnableSagemakerServicecatalogPortfolio(const Model::EnableSagemakerServicecatalogPortfolioRequest& request) const; /** * A Callable wrapper for EnableSagemakerServicecatalogPortfolio that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableSagemakerServicecatalogPortfolioOutcomeCallable EnableSagemakerServicecatalogPortfolioCallable(const EnableSagemakerServicecatalogPortfolioRequestT& request) const { return SubmitCallable(&SageMakerClient::EnableSagemakerServicecatalogPortfolio, request); } /** * An Async wrapper for EnableSagemakerServicecatalogPortfolio that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableSagemakerServicecatalogPortfolioAsync(const EnableSagemakerServicecatalogPortfolioRequestT& request, const EnableSagemakerServicecatalogPortfolioResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::EnableSagemakerServicecatalogPortfolio, request, handler, context); } /** *

Describes a fleet.

See Also:

AWS * API Reference

*/ virtual Model::GetDeviceFleetReportOutcome GetDeviceFleetReport(const Model::GetDeviceFleetReportRequest& request) const; /** * A Callable wrapper for GetDeviceFleetReport that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDeviceFleetReportOutcomeCallable GetDeviceFleetReportCallable(const GetDeviceFleetReportRequestT& request) const { return SubmitCallable(&SageMakerClient::GetDeviceFleetReport, request); } /** * An Async wrapper for GetDeviceFleetReport that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDeviceFleetReportAsync(const GetDeviceFleetReportRequestT& request, const GetDeviceFleetReportResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::GetDeviceFleetReport, request, handler, context); } /** *

The resource policy for the lineage group.

See Also:

AWS * API Reference

*/ virtual Model::GetLineageGroupPolicyOutcome GetLineageGroupPolicy(const Model::GetLineageGroupPolicyRequest& request) const; /** * A Callable wrapper for GetLineageGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLineageGroupPolicyOutcomeCallable GetLineageGroupPolicyCallable(const GetLineageGroupPolicyRequestT& request) const { return SubmitCallable(&SageMakerClient::GetLineageGroupPolicy, request); } /** * An Async wrapper for GetLineageGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLineageGroupPolicyAsync(const GetLineageGroupPolicyRequestT& request, const GetLineageGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::GetLineageGroupPolicy, request, handler, context); } /** *

Gets a resource policy that manages access for a model group. For information * about resource policies, see Identity-based * policies and resource-based policies in the Amazon Web Services Identity * and Access Management User Guide..

See Also:

AWS * API Reference

*/ virtual Model::GetModelPackageGroupPolicyOutcome GetModelPackageGroupPolicy(const Model::GetModelPackageGroupPolicyRequest& request) const; /** * A Callable wrapper for GetModelPackageGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetModelPackageGroupPolicyOutcomeCallable GetModelPackageGroupPolicyCallable(const GetModelPackageGroupPolicyRequestT& request) const { return SubmitCallable(&SageMakerClient::GetModelPackageGroupPolicy, request); } /** * An Async wrapper for GetModelPackageGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetModelPackageGroupPolicyAsync(const GetModelPackageGroupPolicyRequestT& request, const GetModelPackageGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::GetModelPackageGroupPolicy, request, handler, context); } /** *

Gets the status of Service Catalog in SageMaker. Service Catalog is used to * create SageMaker projects.

See Also:

AWS * API Reference

*/ virtual Model::GetSagemakerServicecatalogPortfolioStatusOutcome GetSagemakerServicecatalogPortfolioStatus(const Model::GetSagemakerServicecatalogPortfolioStatusRequest& request) const; /** * A Callable wrapper for GetSagemakerServicecatalogPortfolioStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSagemakerServicecatalogPortfolioStatusOutcomeCallable GetSagemakerServicecatalogPortfolioStatusCallable(const GetSagemakerServicecatalogPortfolioStatusRequestT& request) const { return SubmitCallable(&SageMakerClient::GetSagemakerServicecatalogPortfolioStatus, request); } /** * An Async wrapper for GetSagemakerServicecatalogPortfolioStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSagemakerServicecatalogPortfolioStatusAsync(const GetSagemakerServicecatalogPortfolioStatusRequestT& request, const GetSagemakerServicecatalogPortfolioStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::GetSagemakerServicecatalogPortfolioStatus, request, handler, context); } /** *

An auto-complete API for the search functionality in the SageMaker console. * It returns suggestions of possible matches for the property name to use in * Search queries. Provides suggestions for * HyperParameters, Tags, and * Metrics.

See Also:

AWS * API Reference

*/ virtual Model::GetSearchSuggestionsOutcome GetSearchSuggestions(const Model::GetSearchSuggestionsRequest& request) const; /** * A Callable wrapper for GetSearchSuggestions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSearchSuggestionsOutcomeCallable GetSearchSuggestionsCallable(const GetSearchSuggestionsRequestT& request) const { return SubmitCallable(&SageMakerClient::GetSearchSuggestions, request); } /** * An Async wrapper for GetSearchSuggestions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSearchSuggestionsAsync(const GetSearchSuggestionsRequestT& request, const GetSearchSuggestionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::GetSearchSuggestions, request, handler, context); } /** *

Import hub content.

Hub APIs are only callable through * SageMaker Studio.

See Also:

AWS * API Reference

*/ virtual Model::ImportHubContentOutcome ImportHubContent(const Model::ImportHubContentRequest& request) const; /** * A Callable wrapper for ImportHubContent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportHubContentOutcomeCallable ImportHubContentCallable(const ImportHubContentRequestT& request) const { return SubmitCallable(&SageMakerClient::ImportHubContent, request); } /** * An Async wrapper for ImportHubContent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportHubContentAsync(const ImportHubContentRequestT& request, const ImportHubContentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ImportHubContent, request, handler, context); } /** *

Lists the actions in your account and their properties.

See * Also:

AWS * API Reference

*/ virtual Model::ListActionsOutcome ListActions(const Model::ListActionsRequest& request) const; /** * A Callable wrapper for ListActions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListActionsOutcomeCallable ListActionsCallable(const ListActionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListActions, request); } /** * An Async wrapper for ListActions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListActionsAsync(const ListActionsRequestT& request, const ListActionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListActions, request, handler, context); } /** *

Lists the machine learning algorithms that have been created.

See * Also:

AWS * API Reference

*/ virtual Model::ListAlgorithmsOutcome ListAlgorithms(const Model::ListAlgorithmsRequest& request) const; /** * A Callable wrapper for ListAlgorithms that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAlgorithmsOutcomeCallable ListAlgorithmsCallable(const ListAlgorithmsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListAlgorithms, request); } /** * An Async wrapper for ListAlgorithms that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAlgorithmsAsync(const ListAlgorithmsRequestT& request, const ListAlgorithmsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListAlgorithms, request, handler, context); } /** *

Lists the aliases of a specified image or image version.

See * Also:

AWS * API Reference

*/ virtual Model::ListAliasesOutcome ListAliases(const Model::ListAliasesRequest& request) const; /** * A Callable wrapper for ListAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAliasesOutcomeCallable ListAliasesCallable(const ListAliasesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListAliases, request); } /** * An Async wrapper for ListAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAliasesAsync(const ListAliasesRequestT& request, const ListAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListAliases, request, handler, context); } /** *

Lists the AppImageConfigs in your account and their properties. The list can * be filtered by creation time or modified time, and whether the AppImageConfig * name contains a specified string.

See Also:

AWS * API Reference

*/ virtual Model::ListAppImageConfigsOutcome ListAppImageConfigs(const Model::ListAppImageConfigsRequest& request) const; /** * A Callable wrapper for ListAppImageConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAppImageConfigsOutcomeCallable ListAppImageConfigsCallable(const ListAppImageConfigsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListAppImageConfigs, request); } /** * An Async wrapper for ListAppImageConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAppImageConfigsAsync(const ListAppImageConfigsRequestT& request, const ListAppImageConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListAppImageConfigs, request, handler, context); } /** *

Lists apps.

See Also:

AWS * API Reference

*/ virtual Model::ListAppsOutcome ListApps(const Model::ListAppsRequest& request) const; /** * A Callable wrapper for ListApps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAppsOutcomeCallable ListAppsCallable(const ListAppsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListApps, request); } /** * An Async wrapper for ListApps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAppsAsync(const ListAppsRequestT& request, const ListAppsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListApps, request, handler, context); } /** *

Lists the artifacts in your account and their properties.

See * Also:

AWS * API Reference

*/ virtual Model::ListArtifactsOutcome ListArtifacts(const Model::ListArtifactsRequest& request) const; /** * A Callable wrapper for ListArtifacts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListArtifactsOutcomeCallable ListArtifactsCallable(const ListArtifactsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListArtifacts, request); } /** * An Async wrapper for ListArtifacts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListArtifactsAsync(const ListArtifactsRequestT& request, const ListArtifactsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListArtifacts, request, handler, context); } /** *

Lists the associations in your account and their properties.

See * Also:

AWS * API Reference

*/ virtual Model::ListAssociationsOutcome ListAssociations(const Model::ListAssociationsRequest& request) const; /** * A Callable wrapper for ListAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssociationsOutcomeCallable ListAssociationsCallable(const ListAssociationsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListAssociations, request); } /** * An Async wrapper for ListAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssociationsAsync(const ListAssociationsRequestT& request, const ListAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListAssociations, request, handler, context); } /** *

Request a list of jobs.

See Also:

AWS * API Reference

*/ virtual Model::ListAutoMLJobsOutcome ListAutoMLJobs(const Model::ListAutoMLJobsRequest& request) const; /** * A Callable wrapper for ListAutoMLJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAutoMLJobsOutcomeCallable ListAutoMLJobsCallable(const ListAutoMLJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListAutoMLJobs, request); } /** * An Async wrapper for ListAutoMLJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAutoMLJobsAsync(const ListAutoMLJobsRequestT& request, const ListAutoMLJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListAutoMLJobs, request, handler, context); } /** *

List the candidates created for the job.

See Also:

AWS * API Reference

*/ virtual Model::ListCandidatesForAutoMLJobOutcome ListCandidatesForAutoMLJob(const Model::ListCandidatesForAutoMLJobRequest& request) const; /** * A Callable wrapper for ListCandidatesForAutoMLJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCandidatesForAutoMLJobOutcomeCallable ListCandidatesForAutoMLJobCallable(const ListCandidatesForAutoMLJobRequestT& request) const { return SubmitCallable(&SageMakerClient::ListCandidatesForAutoMLJob, request); } /** * An Async wrapper for ListCandidatesForAutoMLJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCandidatesForAutoMLJobAsync(const ListCandidatesForAutoMLJobRequestT& request, const ListCandidatesForAutoMLJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListCandidatesForAutoMLJob, request, handler, context); } /** *

Gets a list of the Git repositories in your account.

See Also:

* AWS * API Reference

*/ virtual Model::ListCodeRepositoriesOutcome ListCodeRepositories(const Model::ListCodeRepositoriesRequest& request) const; /** * A Callable wrapper for ListCodeRepositories that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCodeRepositoriesOutcomeCallable ListCodeRepositoriesCallable(const ListCodeRepositoriesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListCodeRepositories, request); } /** * An Async wrapper for ListCodeRepositories that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCodeRepositoriesAsync(const ListCodeRepositoriesRequestT& request, const ListCodeRepositoriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListCodeRepositories, request, handler, context); } /** *

Lists model compilation jobs that satisfy various filters.

To create a * model compilation job, use CreateCompilationJob. * To get information about a particular model compilation job you have created, * use DescribeCompilationJob.

See * Also:

AWS * API Reference

*/ virtual Model::ListCompilationJobsOutcome ListCompilationJobs(const Model::ListCompilationJobsRequest& request) const; /** * A Callable wrapper for ListCompilationJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCompilationJobsOutcomeCallable ListCompilationJobsCallable(const ListCompilationJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListCompilationJobs, request); } /** * An Async wrapper for ListCompilationJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCompilationJobsAsync(const ListCompilationJobsRequestT& request, const ListCompilationJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListCompilationJobs, request, handler, context); } /** *

Lists the contexts in your account and their properties.

See * Also:

AWS * API Reference

*/ virtual Model::ListContextsOutcome ListContexts(const Model::ListContextsRequest& request) const; /** * A Callable wrapper for ListContexts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListContextsOutcomeCallable ListContextsCallable(const ListContextsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListContexts, request); } /** * An Async wrapper for ListContexts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListContextsAsync(const ListContextsRequestT& request, const ListContextsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListContexts, request, handler, context); } /** *

Lists the data quality job definitions in your account.

See * Also:

AWS * API Reference

*/ virtual Model::ListDataQualityJobDefinitionsOutcome ListDataQualityJobDefinitions(const Model::ListDataQualityJobDefinitionsRequest& request) const; /** * A Callable wrapper for ListDataQualityJobDefinitions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDataQualityJobDefinitionsOutcomeCallable ListDataQualityJobDefinitionsCallable(const ListDataQualityJobDefinitionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListDataQualityJobDefinitions, request); } /** * An Async wrapper for ListDataQualityJobDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDataQualityJobDefinitionsAsync(const ListDataQualityJobDefinitionsRequestT& request, const ListDataQualityJobDefinitionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListDataQualityJobDefinitions, request, handler, context); } /** *

Returns a list of devices in the fleet.

See Also:

AWS * API Reference

*/ virtual Model::ListDeviceFleetsOutcome ListDeviceFleets(const Model::ListDeviceFleetsRequest& request) const; /** * A Callable wrapper for ListDeviceFleets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDeviceFleetsOutcomeCallable ListDeviceFleetsCallable(const ListDeviceFleetsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListDeviceFleets, request); } /** * An Async wrapper for ListDeviceFleets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDeviceFleetsAsync(const ListDeviceFleetsRequestT& request, const ListDeviceFleetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListDeviceFleets, request, handler, context); } /** *

A list of devices.

See Also:

AWS * API Reference

*/ virtual Model::ListDevicesOutcome ListDevices(const Model::ListDevicesRequest& request) const; /** * A Callable wrapper for ListDevices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDevicesOutcomeCallable ListDevicesCallable(const ListDevicesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListDevices, request); } /** * An Async wrapper for ListDevices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDevicesAsync(const ListDevicesRequestT& request, const ListDevicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListDevices, request, handler, context); } /** *

Lists the domains.

See Also:

AWS * API Reference

*/ virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request) const; /** * A Callable wrapper for ListDomains that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListDomains, request); } /** * An Async wrapper for ListDomains that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDomainsAsync(const ListDomainsRequestT& request, const ListDomainsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListDomains, request, handler, context); } /** *

Lists all edge deployment plans.

See Also:

AWS * API Reference

*/ virtual Model::ListEdgeDeploymentPlansOutcome ListEdgeDeploymentPlans(const Model::ListEdgeDeploymentPlansRequest& request) const; /** * A Callable wrapper for ListEdgeDeploymentPlans that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEdgeDeploymentPlansOutcomeCallable ListEdgeDeploymentPlansCallable(const ListEdgeDeploymentPlansRequestT& request) const { return SubmitCallable(&SageMakerClient::ListEdgeDeploymentPlans, request); } /** * An Async wrapper for ListEdgeDeploymentPlans that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEdgeDeploymentPlansAsync(const ListEdgeDeploymentPlansRequestT& request, const ListEdgeDeploymentPlansResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListEdgeDeploymentPlans, request, handler, context); } /** *

Returns a list of edge packaging jobs.

See Also:

AWS * API Reference

*/ virtual Model::ListEdgePackagingJobsOutcome ListEdgePackagingJobs(const Model::ListEdgePackagingJobsRequest& request) const; /** * A Callable wrapper for ListEdgePackagingJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEdgePackagingJobsOutcomeCallable ListEdgePackagingJobsCallable(const ListEdgePackagingJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListEdgePackagingJobs, request); } /** * An Async wrapper for ListEdgePackagingJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEdgePackagingJobsAsync(const ListEdgePackagingJobsRequestT& request, const ListEdgePackagingJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListEdgePackagingJobs, request, handler, context); } /** *

Lists endpoint configurations.

See Also:

AWS * API Reference

*/ virtual Model::ListEndpointConfigsOutcome ListEndpointConfigs(const Model::ListEndpointConfigsRequest& request) const; /** * A Callable wrapper for ListEndpointConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEndpointConfigsOutcomeCallable ListEndpointConfigsCallable(const ListEndpointConfigsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListEndpointConfigs, request); } /** * An Async wrapper for ListEndpointConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEndpointConfigsAsync(const ListEndpointConfigsRequestT& request, const ListEndpointConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListEndpointConfigs, request, handler, context); } /** *

Lists endpoints.

See Also:

AWS * API Reference

*/ virtual Model::ListEndpointsOutcome ListEndpoints(const Model::ListEndpointsRequest& request) const; /** * A Callable wrapper for ListEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEndpointsOutcomeCallable ListEndpointsCallable(const ListEndpointsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListEndpoints, request); } /** * An Async wrapper for ListEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEndpointsAsync(const ListEndpointsRequestT& request, const ListEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListEndpoints, request, handler, context); } /** *

Lists all the experiments in your account. The list can be filtered to show * only experiments that were created in a specific time range. The list can be * sorted by experiment name or creation time.

See Also:

AWS * API Reference

*/ virtual Model::ListExperimentsOutcome ListExperiments(const Model::ListExperimentsRequest& request) const; /** * A Callable wrapper for ListExperiments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListExperimentsOutcomeCallable ListExperimentsCallable(const ListExperimentsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListExperiments, request); } /** * An Async wrapper for ListExperiments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListExperimentsAsync(const ListExperimentsRequestT& request, const ListExperimentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListExperiments, request, handler, context); } /** *

List FeatureGroups based on given filter and * order.

See Also:

AWS * API Reference

*/ virtual Model::ListFeatureGroupsOutcome ListFeatureGroups(const Model::ListFeatureGroupsRequest& request) const; /** * A Callable wrapper for ListFeatureGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFeatureGroupsOutcomeCallable ListFeatureGroupsCallable(const ListFeatureGroupsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListFeatureGroups, request); } /** * An Async wrapper for ListFeatureGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFeatureGroupsAsync(const ListFeatureGroupsRequestT& request, const ListFeatureGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListFeatureGroups, request, handler, context); } /** *

Returns information about the flow definitions in your account.

See * Also:

AWS * API Reference

*/ virtual Model::ListFlowDefinitionsOutcome ListFlowDefinitions(const Model::ListFlowDefinitionsRequest& request) const; /** * A Callable wrapper for ListFlowDefinitions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFlowDefinitionsOutcomeCallable ListFlowDefinitionsCallable(const ListFlowDefinitionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListFlowDefinitions, request); } /** * An Async wrapper for ListFlowDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFlowDefinitionsAsync(const ListFlowDefinitionsRequestT& request, const ListFlowDefinitionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListFlowDefinitions, request, handler, context); } /** *

List hub content versions.

Hub APIs are only callable through * SageMaker Studio.

See Also:

AWS * API Reference

*/ virtual Model::ListHubContentVersionsOutcome ListHubContentVersions(const Model::ListHubContentVersionsRequest& request) const; /** * A Callable wrapper for ListHubContentVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHubContentVersionsOutcomeCallable ListHubContentVersionsCallable(const ListHubContentVersionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListHubContentVersions, request); } /** * An Async wrapper for ListHubContentVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHubContentVersionsAsync(const ListHubContentVersionsRequestT& request, const ListHubContentVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListHubContentVersions, request, handler, context); } /** *

List the contents of a hub.

Hub APIs are only callable through * SageMaker Studio.

See Also:

AWS * API Reference

*/ virtual Model::ListHubContentsOutcome ListHubContents(const Model::ListHubContentsRequest& request) const; /** * A Callable wrapper for ListHubContents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHubContentsOutcomeCallable ListHubContentsCallable(const ListHubContentsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListHubContents, request); } /** * An Async wrapper for ListHubContents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHubContentsAsync(const ListHubContentsRequestT& request, const ListHubContentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListHubContents, request, handler, context); } /** *

List all existing hubs.

Hub APIs are only callable through * SageMaker Studio.

See Also:

AWS * API Reference

*/ virtual Model::ListHubsOutcome ListHubs(const Model::ListHubsRequest& request) const; /** * A Callable wrapper for ListHubs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHubsOutcomeCallable ListHubsCallable(const ListHubsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListHubs, request); } /** * An Async wrapper for ListHubs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHubsAsync(const ListHubsRequestT& request, const ListHubsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListHubs, request, handler, context); } /** *

Returns information about the human task user interfaces in your * account.

See Also:

AWS * API Reference

*/ virtual Model::ListHumanTaskUisOutcome ListHumanTaskUis(const Model::ListHumanTaskUisRequest& request) const; /** * A Callable wrapper for ListHumanTaskUis that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHumanTaskUisOutcomeCallable ListHumanTaskUisCallable(const ListHumanTaskUisRequestT& request) const { return SubmitCallable(&SageMakerClient::ListHumanTaskUis, request); } /** * An Async wrapper for ListHumanTaskUis that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHumanTaskUisAsync(const ListHumanTaskUisRequestT& request, const ListHumanTaskUisResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListHumanTaskUis, request, handler, context); } /** *

Gets a list of HyperParameterTuningJobSummary * objects that describe the hyperparameter tuning jobs launched in your * account.

See Also:

AWS * API Reference

*/ virtual Model::ListHyperParameterTuningJobsOutcome ListHyperParameterTuningJobs(const Model::ListHyperParameterTuningJobsRequest& request) const; /** * A Callable wrapper for ListHyperParameterTuningJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHyperParameterTuningJobsOutcomeCallable ListHyperParameterTuningJobsCallable(const ListHyperParameterTuningJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListHyperParameterTuningJobs, request); } /** * An Async wrapper for ListHyperParameterTuningJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHyperParameterTuningJobsAsync(const ListHyperParameterTuningJobsRequestT& request, const ListHyperParameterTuningJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListHyperParameterTuningJobs, request, handler, context); } /** *

Lists the versions of a specified image and their properties. The list can be * filtered by creation time or modified time.

See Also:

AWS * API Reference

*/ virtual Model::ListImageVersionsOutcome ListImageVersions(const Model::ListImageVersionsRequest& request) const; /** * A Callable wrapper for ListImageVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListImageVersionsOutcomeCallable ListImageVersionsCallable(const ListImageVersionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListImageVersions, request); } /** * An Async wrapper for ListImageVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListImageVersionsAsync(const ListImageVersionsRequestT& request, const ListImageVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListImageVersions, request, handler, context); } /** *

Lists the images in your account and their properties. The list can be * filtered by creation time or modified time, and whether the image name contains * a specified string.

See Also:

AWS * API Reference

*/ virtual Model::ListImagesOutcome ListImages(const Model::ListImagesRequest& request) const; /** * A Callable wrapper for ListImages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListImagesOutcomeCallable ListImagesCallable(const ListImagesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListImages, request); } /** * An Async wrapper for ListImages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListImagesAsync(const ListImagesRequestT& request, const ListImagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListImages, request, handler, context); } /** *

Returns the list of all inference experiments.

See Also:

AWS * API Reference

*/ virtual Model::ListInferenceExperimentsOutcome ListInferenceExperiments(const Model::ListInferenceExperimentsRequest& request) const; /** * A Callable wrapper for ListInferenceExperiments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListInferenceExperimentsOutcomeCallable ListInferenceExperimentsCallable(const ListInferenceExperimentsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListInferenceExperiments, request); } /** * An Async wrapper for ListInferenceExperiments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListInferenceExperimentsAsync(const ListInferenceExperimentsRequestT& request, const ListInferenceExperimentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListInferenceExperiments, request, handler, context); } /** *

Returns a list of the subtasks for an Inference Recommender job.

The * supported subtasks are benchmarks, which evaluate the performance of your model * on different instance types.

See Also:

AWS * API Reference

*/ virtual Model::ListInferenceRecommendationsJobStepsOutcome ListInferenceRecommendationsJobSteps(const Model::ListInferenceRecommendationsJobStepsRequest& request) const; /** * A Callable wrapper for ListInferenceRecommendationsJobSteps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListInferenceRecommendationsJobStepsOutcomeCallable ListInferenceRecommendationsJobStepsCallable(const ListInferenceRecommendationsJobStepsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListInferenceRecommendationsJobSteps, request); } /** * An Async wrapper for ListInferenceRecommendationsJobSteps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListInferenceRecommendationsJobStepsAsync(const ListInferenceRecommendationsJobStepsRequestT& request, const ListInferenceRecommendationsJobStepsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListInferenceRecommendationsJobSteps, request, handler, context); } /** *

Lists recommendation jobs that satisfy various filters.

See * Also:

AWS * API Reference

*/ virtual Model::ListInferenceRecommendationsJobsOutcome ListInferenceRecommendationsJobs(const Model::ListInferenceRecommendationsJobsRequest& request) const; /** * A Callable wrapper for ListInferenceRecommendationsJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListInferenceRecommendationsJobsOutcomeCallable ListInferenceRecommendationsJobsCallable(const ListInferenceRecommendationsJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListInferenceRecommendationsJobs, request); } /** * An Async wrapper for ListInferenceRecommendationsJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListInferenceRecommendationsJobsAsync(const ListInferenceRecommendationsJobsRequestT& request, const ListInferenceRecommendationsJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListInferenceRecommendationsJobs, request, handler, context); } /** *

Gets a list of labeling jobs.

See Also:

AWS * API Reference

*/ virtual Model::ListLabelingJobsOutcome ListLabelingJobs(const Model::ListLabelingJobsRequest& request) const; /** * A Callable wrapper for ListLabelingJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListLabelingJobsOutcomeCallable ListLabelingJobsCallable(const ListLabelingJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListLabelingJobs, request); } /** * An Async wrapper for ListLabelingJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListLabelingJobsAsync(const ListLabelingJobsRequestT& request, const ListLabelingJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListLabelingJobs, request, handler, context); } /** *

Gets a list of labeling jobs assigned to a specified work team.

See * Also:

AWS * API Reference

*/ virtual Model::ListLabelingJobsForWorkteamOutcome ListLabelingJobsForWorkteam(const Model::ListLabelingJobsForWorkteamRequest& request) const; /** * A Callable wrapper for ListLabelingJobsForWorkteam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListLabelingJobsForWorkteamOutcomeCallable ListLabelingJobsForWorkteamCallable(const ListLabelingJobsForWorkteamRequestT& request) const { return SubmitCallable(&SageMakerClient::ListLabelingJobsForWorkteam, request); } /** * An Async wrapper for ListLabelingJobsForWorkteam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListLabelingJobsForWorkteamAsync(const ListLabelingJobsForWorkteamRequestT& request, const ListLabelingJobsForWorkteamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListLabelingJobsForWorkteam, request, handler, context); } /** *

A list of lineage groups shared with your Amazon Web Services account. For * more information, see * Cross-Account Lineage Tracking in the Amazon SageMaker Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListLineageGroupsOutcome ListLineageGroups(const Model::ListLineageGroupsRequest& request) const; /** * A Callable wrapper for ListLineageGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListLineageGroupsOutcomeCallable ListLineageGroupsCallable(const ListLineageGroupsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListLineageGroups, request); } /** * An Async wrapper for ListLineageGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListLineageGroupsAsync(const ListLineageGroupsRequestT& request, const ListLineageGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListLineageGroups, request, handler, context); } /** *

Lists model bias jobs definitions that satisfy various filters.

See * Also:

AWS * API Reference

*/ virtual Model::ListModelBiasJobDefinitionsOutcome ListModelBiasJobDefinitions(const Model::ListModelBiasJobDefinitionsRequest& request) const; /** * A Callable wrapper for ListModelBiasJobDefinitions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelBiasJobDefinitionsOutcomeCallable ListModelBiasJobDefinitionsCallable(const ListModelBiasJobDefinitionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModelBiasJobDefinitions, request); } /** * An Async wrapper for ListModelBiasJobDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelBiasJobDefinitionsAsync(const ListModelBiasJobDefinitionsRequestT& request, const ListModelBiasJobDefinitionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModelBiasJobDefinitions, request, handler, context); } /** *

List the export jobs for the Amazon SageMaker Model Card.

See * Also:

AWS * API Reference

*/ virtual Model::ListModelCardExportJobsOutcome ListModelCardExportJobs(const Model::ListModelCardExportJobsRequest& request) const; /** * A Callable wrapper for ListModelCardExportJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelCardExportJobsOutcomeCallable ListModelCardExportJobsCallable(const ListModelCardExportJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModelCardExportJobs, request); } /** * An Async wrapper for ListModelCardExportJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelCardExportJobsAsync(const ListModelCardExportJobsRequestT& request, const ListModelCardExportJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModelCardExportJobs, request, handler, context); } /** *

List existing versions of an Amazon SageMaker Model Card.

See * Also:

AWS * API Reference

*/ virtual Model::ListModelCardVersionsOutcome ListModelCardVersions(const Model::ListModelCardVersionsRequest& request) const; /** * A Callable wrapper for ListModelCardVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelCardVersionsOutcomeCallable ListModelCardVersionsCallable(const ListModelCardVersionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModelCardVersions, request); } /** * An Async wrapper for ListModelCardVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelCardVersionsAsync(const ListModelCardVersionsRequestT& request, const ListModelCardVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModelCardVersions, request, handler, context); } /** *

List existing model cards.

See Also:

AWS * API Reference

*/ virtual Model::ListModelCardsOutcome ListModelCards(const Model::ListModelCardsRequest& request) const; /** * A Callable wrapper for ListModelCards that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelCardsOutcomeCallable ListModelCardsCallable(const ListModelCardsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModelCards, request); } /** * An Async wrapper for ListModelCards that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelCardsAsync(const ListModelCardsRequestT& request, const ListModelCardsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModelCards, request, handler, context); } /** *

Lists model explainability job definitions that satisfy various * filters.

See Also:

AWS * API Reference

*/ virtual Model::ListModelExplainabilityJobDefinitionsOutcome ListModelExplainabilityJobDefinitions(const Model::ListModelExplainabilityJobDefinitionsRequest& request) const; /** * A Callable wrapper for ListModelExplainabilityJobDefinitions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelExplainabilityJobDefinitionsOutcomeCallable ListModelExplainabilityJobDefinitionsCallable(const ListModelExplainabilityJobDefinitionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModelExplainabilityJobDefinitions, request); } /** * An Async wrapper for ListModelExplainabilityJobDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelExplainabilityJobDefinitionsAsync(const ListModelExplainabilityJobDefinitionsRequestT& request, const ListModelExplainabilityJobDefinitionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModelExplainabilityJobDefinitions, request, handler, context); } /** *

Lists the domain, framework, task, and model name of standard machine * learning models found in common model zoos.

See Also:

AWS * API Reference

*/ virtual Model::ListModelMetadataOutcome ListModelMetadata(const Model::ListModelMetadataRequest& request) const; /** * A Callable wrapper for ListModelMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelMetadataOutcomeCallable ListModelMetadataCallable(const ListModelMetadataRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModelMetadata, request); } /** * An Async wrapper for ListModelMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelMetadataAsync(const ListModelMetadataRequestT& request, const ListModelMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModelMetadata, request, handler, context); } /** *

Gets a list of the model groups in your Amazon Web Services * account.

See Also:

AWS * API Reference

*/ virtual Model::ListModelPackageGroupsOutcome ListModelPackageGroups(const Model::ListModelPackageGroupsRequest& request) const; /** * A Callable wrapper for ListModelPackageGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelPackageGroupsOutcomeCallable ListModelPackageGroupsCallable(const ListModelPackageGroupsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModelPackageGroups, request); } /** * An Async wrapper for ListModelPackageGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelPackageGroupsAsync(const ListModelPackageGroupsRequestT& request, const ListModelPackageGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModelPackageGroups, request, handler, context); } /** *

Lists the model packages that have been created.

See Also:

* AWS * API Reference

*/ virtual Model::ListModelPackagesOutcome ListModelPackages(const Model::ListModelPackagesRequest& request) const; /** * A Callable wrapper for ListModelPackages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelPackagesOutcomeCallable ListModelPackagesCallable(const ListModelPackagesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModelPackages, request); } /** * An Async wrapper for ListModelPackages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelPackagesAsync(const ListModelPackagesRequestT& request, const ListModelPackagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModelPackages, request, handler, context); } /** *

Gets a list of model quality monitoring job definitions in your * account.

See Also:

AWS * API Reference

*/ virtual Model::ListModelQualityJobDefinitionsOutcome ListModelQualityJobDefinitions(const Model::ListModelQualityJobDefinitionsRequest& request) const; /** * A Callable wrapper for ListModelQualityJobDefinitions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelQualityJobDefinitionsOutcomeCallable ListModelQualityJobDefinitionsCallable(const ListModelQualityJobDefinitionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModelQualityJobDefinitions, request); } /** * An Async wrapper for ListModelQualityJobDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelQualityJobDefinitionsAsync(const ListModelQualityJobDefinitionsRequestT& request, const ListModelQualityJobDefinitionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModelQualityJobDefinitions, request, handler, context); } /** *

Lists models created with the CreateModel API.

See * Also:

AWS * API Reference

*/ virtual Model::ListModelsOutcome ListModels(const Model::ListModelsRequest& request) const; /** * A Callable wrapper for ListModels that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListModelsOutcomeCallable ListModelsCallable(const ListModelsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListModels, request); } /** * An Async wrapper for ListModels that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListModelsAsync(const ListModelsRequestT& request, const ListModelsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListModels, request, handler, context); } /** *

Gets a list of past alerts in a model monitoring schedule.

See * Also:

AWS * API Reference

*/ virtual Model::ListMonitoringAlertHistoryOutcome ListMonitoringAlertHistory(const Model::ListMonitoringAlertHistoryRequest& request) const; /** * A Callable wrapper for ListMonitoringAlertHistory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMonitoringAlertHistoryOutcomeCallable ListMonitoringAlertHistoryCallable(const ListMonitoringAlertHistoryRequestT& request) const { return SubmitCallable(&SageMakerClient::ListMonitoringAlertHistory, request); } /** * An Async wrapper for ListMonitoringAlertHistory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMonitoringAlertHistoryAsync(const ListMonitoringAlertHistoryRequestT& request, const ListMonitoringAlertHistoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListMonitoringAlertHistory, request, handler, context); } /** *

Gets the alerts for a single monitoring schedule.

See Also:

* AWS * API Reference

*/ virtual Model::ListMonitoringAlertsOutcome ListMonitoringAlerts(const Model::ListMonitoringAlertsRequest& request) const; /** * A Callable wrapper for ListMonitoringAlerts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMonitoringAlertsOutcomeCallable ListMonitoringAlertsCallable(const ListMonitoringAlertsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListMonitoringAlerts, request); } /** * An Async wrapper for ListMonitoringAlerts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMonitoringAlertsAsync(const ListMonitoringAlertsRequestT& request, const ListMonitoringAlertsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListMonitoringAlerts, request, handler, context); } /** *

Returns list of all monitoring job executions.

See Also:

AWS * API Reference

*/ virtual Model::ListMonitoringExecutionsOutcome ListMonitoringExecutions(const Model::ListMonitoringExecutionsRequest& request) const; /** * A Callable wrapper for ListMonitoringExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMonitoringExecutionsOutcomeCallable ListMonitoringExecutionsCallable(const ListMonitoringExecutionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListMonitoringExecutions, request); } /** * An Async wrapper for ListMonitoringExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMonitoringExecutionsAsync(const ListMonitoringExecutionsRequestT& request, const ListMonitoringExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListMonitoringExecutions, request, handler, context); } /** *

Returns list of all monitoring schedules.

See Also:

AWS * API Reference

*/ virtual Model::ListMonitoringSchedulesOutcome ListMonitoringSchedules(const Model::ListMonitoringSchedulesRequest& request) const; /** * A Callable wrapper for ListMonitoringSchedules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMonitoringSchedulesOutcomeCallable ListMonitoringSchedulesCallable(const ListMonitoringSchedulesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListMonitoringSchedules, request); } /** * An Async wrapper for ListMonitoringSchedules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMonitoringSchedulesAsync(const ListMonitoringSchedulesRequestT& request, const ListMonitoringSchedulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListMonitoringSchedules, request, handler, context); } /** *

Lists notebook instance lifestyle configurations created with the CreateNotebookInstanceLifecycleConfig * API.

See Also:

AWS * API Reference

*/ virtual Model::ListNotebookInstanceLifecycleConfigsOutcome ListNotebookInstanceLifecycleConfigs(const Model::ListNotebookInstanceLifecycleConfigsRequest& request) const; /** * A Callable wrapper for ListNotebookInstanceLifecycleConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListNotebookInstanceLifecycleConfigsOutcomeCallable ListNotebookInstanceLifecycleConfigsCallable(const ListNotebookInstanceLifecycleConfigsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListNotebookInstanceLifecycleConfigs, request); } /** * An Async wrapper for ListNotebookInstanceLifecycleConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListNotebookInstanceLifecycleConfigsAsync(const ListNotebookInstanceLifecycleConfigsRequestT& request, const ListNotebookInstanceLifecycleConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListNotebookInstanceLifecycleConfigs, request, handler, context); } /** *

Returns a list of the SageMaker notebook instances in the requester's account * in an Amazon Web Services Region.

See Also:

AWS * API Reference

*/ virtual Model::ListNotebookInstancesOutcome ListNotebookInstances(const Model::ListNotebookInstancesRequest& request) const; /** * A Callable wrapper for ListNotebookInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListNotebookInstancesOutcomeCallable ListNotebookInstancesCallable(const ListNotebookInstancesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListNotebookInstances, request); } /** * An Async wrapper for ListNotebookInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListNotebookInstancesAsync(const ListNotebookInstancesRequestT& request, const ListNotebookInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListNotebookInstances, request, handler, context); } /** *

Gets a list of PipeLineExecutionStep objects.

See * Also:

AWS * API Reference

*/ virtual Model::ListPipelineExecutionStepsOutcome ListPipelineExecutionSteps(const Model::ListPipelineExecutionStepsRequest& request) const; /** * A Callable wrapper for ListPipelineExecutionSteps that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPipelineExecutionStepsOutcomeCallable ListPipelineExecutionStepsCallable(const ListPipelineExecutionStepsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListPipelineExecutionSteps, request); } /** * An Async wrapper for ListPipelineExecutionSteps that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPipelineExecutionStepsAsync(const ListPipelineExecutionStepsRequestT& request, const ListPipelineExecutionStepsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListPipelineExecutionSteps, request, handler, context); } /** *

Gets a list of the pipeline executions.

See Also:

AWS * API Reference

*/ virtual Model::ListPipelineExecutionsOutcome ListPipelineExecutions(const Model::ListPipelineExecutionsRequest& request) const; /** * A Callable wrapper for ListPipelineExecutions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPipelineExecutionsOutcomeCallable ListPipelineExecutionsCallable(const ListPipelineExecutionsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListPipelineExecutions, request); } /** * An Async wrapper for ListPipelineExecutions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPipelineExecutionsAsync(const ListPipelineExecutionsRequestT& request, const ListPipelineExecutionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListPipelineExecutions, request, handler, context); } /** *

Gets a list of parameters for a pipeline execution.

See Also:

* AWS * API Reference

*/ virtual Model::ListPipelineParametersForExecutionOutcome ListPipelineParametersForExecution(const Model::ListPipelineParametersForExecutionRequest& request) const; /** * A Callable wrapper for ListPipelineParametersForExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPipelineParametersForExecutionOutcomeCallable ListPipelineParametersForExecutionCallable(const ListPipelineParametersForExecutionRequestT& request) const { return SubmitCallable(&SageMakerClient::ListPipelineParametersForExecution, request); } /** * An Async wrapper for ListPipelineParametersForExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPipelineParametersForExecutionAsync(const ListPipelineParametersForExecutionRequestT& request, const ListPipelineParametersForExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListPipelineParametersForExecution, request, handler, context); } /** *

Gets a list of pipelines.

See Also:

AWS * API Reference

*/ virtual Model::ListPipelinesOutcome ListPipelines(const Model::ListPipelinesRequest& request) const; /** * A Callable wrapper for ListPipelines that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPipelinesOutcomeCallable ListPipelinesCallable(const ListPipelinesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListPipelines, request); } /** * An Async wrapper for ListPipelines that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPipelinesAsync(const ListPipelinesRequestT& request, const ListPipelinesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListPipelines, request, handler, context); } /** *

Lists processing jobs that satisfy various filters.

See Also:

* AWS * API Reference

*/ virtual Model::ListProcessingJobsOutcome ListProcessingJobs(const Model::ListProcessingJobsRequest& request) const; /** * A Callable wrapper for ListProcessingJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProcessingJobsOutcomeCallable ListProcessingJobsCallable(const ListProcessingJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListProcessingJobs, request); } /** * An Async wrapper for ListProcessingJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProcessingJobsAsync(const ListProcessingJobsRequestT& request, const ListProcessingJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListProcessingJobs, request, handler, context); } /** *

Gets a list of the projects in an Amazon Web Services account.

See * Also:

AWS * API Reference

*/ virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request) const; /** * A Callable wrapper for ListProjects that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListProjects, request); } /** * An Async wrapper for ListProjects that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListProjectsAsync(const ListProjectsRequestT& request, const ListProjectsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListProjects, request, handler, context); } /** *

Lists Amazon SageMaker Catalogs based on given filters and orders. The * maximum number of ResourceCatalogs viewable is 1000.

See * Also:

AWS * API Reference

*/ virtual Model::ListResourceCatalogsOutcome ListResourceCatalogs(const Model::ListResourceCatalogsRequest& request) const; /** * A Callable wrapper for ListResourceCatalogs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResourceCatalogsOutcomeCallable ListResourceCatalogsCallable(const ListResourceCatalogsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListResourceCatalogs, request); } /** * An Async wrapper for ListResourceCatalogs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResourceCatalogsAsync(const ListResourceCatalogsRequestT& request, const ListResourceCatalogsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListResourceCatalogs, request, handler, context); } /** *

Lists spaces.

See Also:

AWS * API Reference

*/ virtual Model::ListSpacesOutcome ListSpaces(const Model::ListSpacesRequest& request) const; /** * A Callable wrapper for ListSpaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSpacesOutcomeCallable ListSpacesCallable(const ListSpacesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListSpaces, request); } /** * An Async wrapper for ListSpaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSpacesAsync(const ListSpacesRequestT& request, const ListSpacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListSpaces, request, handler, context); } /** *

Lists devices allocated to the stage, containing detailed device information * and deployment status.

See Also:

AWS * API Reference

*/ virtual Model::ListStageDevicesOutcome ListStageDevices(const Model::ListStageDevicesRequest& request) const; /** * A Callable wrapper for ListStageDevices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStageDevicesOutcomeCallable ListStageDevicesCallable(const ListStageDevicesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListStageDevices, request); } /** * An Async wrapper for ListStageDevices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStageDevicesAsync(const ListStageDevicesRequestT& request, const ListStageDevicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListStageDevices, request, handler, context); } /** *

Lists the Studio Lifecycle Configurations in your Amazon Web Services * Account.

See Also:

AWS * API Reference

*/ virtual Model::ListStudioLifecycleConfigsOutcome ListStudioLifecycleConfigs(const Model::ListStudioLifecycleConfigsRequest& request) const; /** * A Callable wrapper for ListStudioLifecycleConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStudioLifecycleConfigsOutcomeCallable ListStudioLifecycleConfigsCallable(const ListStudioLifecycleConfigsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListStudioLifecycleConfigs, request); } /** * An Async wrapper for ListStudioLifecycleConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStudioLifecycleConfigsAsync(const ListStudioLifecycleConfigsRequestT& request, const ListStudioLifecycleConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListStudioLifecycleConfigs, request, handler, context); } /** *

Gets a list of the work teams that you are subscribed to in the Amazon Web * Services Marketplace. The list may be empty if no work team satisfies the filter * specified in the NameContains parameter.

See Also:

* AWS * API Reference

*/ virtual Model::ListSubscribedWorkteamsOutcome ListSubscribedWorkteams(const Model::ListSubscribedWorkteamsRequest& request) const; /** * A Callable wrapper for ListSubscribedWorkteams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSubscribedWorkteamsOutcomeCallable ListSubscribedWorkteamsCallable(const ListSubscribedWorkteamsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListSubscribedWorkteams, request); } /** * An Async wrapper for ListSubscribedWorkteams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSubscribedWorkteamsAsync(const ListSubscribedWorkteamsRequestT& request, const ListSubscribedWorkteamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListSubscribedWorkteams, request, handler, context); } /** *

Returns the tags for the specified SageMaker resource.

See * Also:

AWS * API Reference

*/ virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const; /** * A Callable wrapper for ListTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListTags, request); } /** * An Async wrapper for ListTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListTags, request, handler, context); } /** *

Lists training jobs.

When StatusEquals and * MaxResults are set at the same time, the MaxResults * number of training jobs are first retrieved ignoring the * StatusEquals parameter and then they are filtered by the * StatusEquals parameter, which is returned as a response.

For * example, if ListTrainingJobs is invoked with the following * parameters:

{ ... MaxResults: 100, StatusEquals: InProgress ... * }

First, 100 trainings jobs with any status, including those * other than InProgress, are selected (sorted according to the * creation time, from the most current to the oldest). Next, those with a status * of InProgress are returned.

You can quickly test the API * using the following Amazon Web Services CLI code.

aws sagemaker * list-training-jobs --max-results 100 --status-equals InProgress

*

See Also:

AWS * API Reference

*/ virtual Model::ListTrainingJobsOutcome ListTrainingJobs(const Model::ListTrainingJobsRequest& request) const; /** * A Callable wrapper for ListTrainingJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrainingJobsOutcomeCallable ListTrainingJobsCallable(const ListTrainingJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListTrainingJobs, request); } /** * An Async wrapper for ListTrainingJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrainingJobsAsync(const ListTrainingJobsRequestT& request, const ListTrainingJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListTrainingJobs, request, handler, context); } /** *

Gets a list of TrainingJobSummary * objects that describe the training jobs that a hyperparameter tuning job * launched.

See Also:

AWS * API Reference

*/ virtual Model::ListTrainingJobsForHyperParameterTuningJobOutcome ListTrainingJobsForHyperParameterTuningJob(const Model::ListTrainingJobsForHyperParameterTuningJobRequest& request) const; /** * A Callable wrapper for ListTrainingJobsForHyperParameterTuningJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrainingJobsForHyperParameterTuningJobOutcomeCallable ListTrainingJobsForHyperParameterTuningJobCallable(const ListTrainingJobsForHyperParameterTuningJobRequestT& request) const { return SubmitCallable(&SageMakerClient::ListTrainingJobsForHyperParameterTuningJob, request); } /** * An Async wrapper for ListTrainingJobsForHyperParameterTuningJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrainingJobsForHyperParameterTuningJobAsync(const ListTrainingJobsForHyperParameterTuningJobRequestT& request, const ListTrainingJobsForHyperParameterTuningJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListTrainingJobsForHyperParameterTuningJob, request, handler, context); } /** *

Lists transform jobs.

See Also:

AWS * API Reference

*/ virtual Model::ListTransformJobsOutcome ListTransformJobs(const Model::ListTransformJobsRequest& request) const; /** * A Callable wrapper for ListTransformJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTransformJobsOutcomeCallable ListTransformJobsCallable(const ListTransformJobsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListTransformJobs, request); } /** * An Async wrapper for ListTransformJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTransformJobsAsync(const ListTransformJobsRequestT& request, const ListTransformJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListTransformJobs, request, handler, context); } /** *

Lists the trial components in your account. You can sort the list by trial * component name or creation time. You can filter the list to show only components * that were created in a specific time range. You can also filter on one of the * following:

  • ExperimentName

  • * SourceArn

  • TrialName

    • *

See Also:

AWS * API Reference

*/ virtual Model::ListTrialComponentsOutcome ListTrialComponents(const Model::ListTrialComponentsRequest& request) const; /** * A Callable wrapper for ListTrialComponents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrialComponentsOutcomeCallable ListTrialComponentsCallable(const ListTrialComponentsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListTrialComponents, request); } /** * An Async wrapper for ListTrialComponents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrialComponentsAsync(const ListTrialComponentsRequestT& request, const ListTrialComponentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListTrialComponents, request, handler, context); } /** *

Lists the trials in your account. Specify an experiment name to limit the * list to the trials that are part of that experiment. Specify a trial component * name to limit the list to the trials that associated with that trial component. * The list can be filtered to show only trials that were created in a specific * time range. The list can be sorted by trial name or creation time.

See * Also:

AWS * API Reference

*/ virtual Model::ListTrialsOutcome ListTrials(const Model::ListTrialsRequest& request) const; /** * A Callable wrapper for ListTrials that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTrialsOutcomeCallable ListTrialsCallable(const ListTrialsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListTrials, request); } /** * An Async wrapper for ListTrials that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTrialsAsync(const ListTrialsRequestT& request, const ListTrialsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListTrials, request, handler, context); } /** *

Lists user profiles.

See Also:

AWS * API Reference

*/ virtual Model::ListUserProfilesOutcome ListUserProfiles(const Model::ListUserProfilesRequest& request) const; /** * A Callable wrapper for ListUserProfiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListUserProfilesOutcomeCallable ListUserProfilesCallable(const ListUserProfilesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListUserProfiles, request); } /** * An Async wrapper for ListUserProfiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListUserProfilesAsync(const ListUserProfilesRequestT& request, const ListUserProfilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListUserProfiles, request, handler, context); } /** *

Use this operation to list all private and vendor workforces in an Amazon Web * Services Region. Note that you can only have one private workforce per Amazon * Web Services Region.

See Also:

AWS * API Reference

*/ virtual Model::ListWorkforcesOutcome ListWorkforces(const Model::ListWorkforcesRequest& request) const; /** * A Callable wrapper for ListWorkforces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListWorkforcesOutcomeCallable ListWorkforcesCallable(const ListWorkforcesRequestT& request) const { return SubmitCallable(&SageMakerClient::ListWorkforces, request); } /** * An Async wrapper for ListWorkforces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListWorkforcesAsync(const ListWorkforcesRequestT& request, const ListWorkforcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListWorkforces, request, handler, context); } /** *

Gets a list of private work teams that you have defined in a region. The list * may be empty if no work team satisfies the filter specified in the * NameContains parameter.

See Also:

AWS * API Reference

*/ virtual Model::ListWorkteamsOutcome ListWorkteams(const Model::ListWorkteamsRequest& request) const; /** * A Callable wrapper for ListWorkteams that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListWorkteamsOutcomeCallable ListWorkteamsCallable(const ListWorkteamsRequestT& request) const { return SubmitCallable(&SageMakerClient::ListWorkteams, request); } /** * An Async wrapper for ListWorkteams that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListWorkteamsAsync(const ListWorkteamsRequestT& request, const ListWorkteamsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::ListWorkteams, request, handler, context); } /** *

Adds a resouce policy to control access to a model group. For information * about resoure policies, see Identity-based * policies and resource-based policies in the Amazon Web Services Identity * and Access Management User Guide..

See Also:

AWS * API Reference

*/ virtual Model::PutModelPackageGroupPolicyOutcome PutModelPackageGroupPolicy(const Model::PutModelPackageGroupPolicyRequest& request) const; /** * A Callable wrapper for PutModelPackageGroupPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutModelPackageGroupPolicyOutcomeCallable PutModelPackageGroupPolicyCallable(const PutModelPackageGroupPolicyRequestT& request) const { return SubmitCallable(&SageMakerClient::PutModelPackageGroupPolicy, request); } /** * An Async wrapper for PutModelPackageGroupPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutModelPackageGroupPolicyAsync(const PutModelPackageGroupPolicyRequestT& request, const PutModelPackageGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::PutModelPackageGroupPolicy, request, handler, context); } /** *

Use this action to inspect your lineage and discover relationships between * entities. For more information, see * Querying Lineage Entities in the Amazon SageMaker Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::QueryLineageOutcome QueryLineage(const Model::QueryLineageRequest& request) const; /** * A Callable wrapper for QueryLineage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::QueryLineageOutcomeCallable QueryLineageCallable(const QueryLineageRequestT& request) const { return SubmitCallable(&SageMakerClient::QueryLineage, request); } /** * An Async wrapper for QueryLineage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void QueryLineageAsync(const QueryLineageRequestT& request, const QueryLineageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::QueryLineage, request, handler, context); } /** *

Register devices.

See Also:

AWS * API Reference

*/ virtual Model::RegisterDevicesOutcome RegisterDevices(const Model::RegisterDevicesRequest& request) const; /** * A Callable wrapper for RegisterDevices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterDevicesOutcomeCallable RegisterDevicesCallable(const RegisterDevicesRequestT& request) const { return SubmitCallable(&SageMakerClient::RegisterDevices, request); } /** * An Async wrapper for RegisterDevices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterDevicesAsync(const RegisterDevicesRequestT& request, const RegisterDevicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::RegisterDevices, request, handler, context); } /** *

Renders the UI template so that you can preview the worker's experience. *

See Also:

AWS * API Reference

*/ virtual Model::RenderUiTemplateOutcome RenderUiTemplate(const Model::RenderUiTemplateRequest& request) const; /** * A Callable wrapper for RenderUiTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RenderUiTemplateOutcomeCallable RenderUiTemplateCallable(const RenderUiTemplateRequestT& request) const { return SubmitCallable(&SageMakerClient::RenderUiTemplate, request); } /** * An Async wrapper for RenderUiTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RenderUiTemplateAsync(const RenderUiTemplateRequestT& request, const RenderUiTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::RenderUiTemplate, request, handler, context); } /** *

Retry the execution of the pipeline.

See Also:

AWS * API Reference

*/ virtual Model::RetryPipelineExecutionOutcome RetryPipelineExecution(const Model::RetryPipelineExecutionRequest& request) const; /** * A Callable wrapper for RetryPipelineExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RetryPipelineExecutionOutcomeCallable RetryPipelineExecutionCallable(const RetryPipelineExecutionRequestT& request) const { return SubmitCallable(&SageMakerClient::RetryPipelineExecution, request); } /** * An Async wrapper for RetryPipelineExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RetryPipelineExecutionAsync(const RetryPipelineExecutionRequestT& request, const RetryPipelineExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::RetryPipelineExecution, request, handler, context); } /** *

Finds SageMaker resources that match a search query. Matching resources are * returned as a list of SearchRecord objects in the response. You can * sort the search results by any resource property in a ascending or descending * order.

You can query against the following value types: numeric, text, * Boolean, and timestamp.

The Search API may provide access to * otherwise restricted data. See Amazon * SageMaker API Permissions: Actions, Permissions, and Resources Reference for * more information.

See Also:

AWS * API Reference

*/ virtual Model::SearchOutcome Search(const Model::SearchRequest& request) const; /** * A Callable wrapper for Search that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SearchOutcomeCallable SearchCallable(const SearchRequestT& request) const { return SubmitCallable(&SageMakerClient::Search, request); } /** * An Async wrapper for Search that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SearchAsync(const SearchRequestT& request, const SearchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::Search, request, handler, context); } /** *

Notifies the pipeline that the execution of a callback step failed, along * with a message describing why. When a callback step is run, the pipeline * generates a callback token and includes the token in a message sent to Amazon * Simple Queue Service (Amazon SQS).

See Also:

AWS * API Reference

*/ virtual Model::SendPipelineExecutionStepFailureOutcome SendPipelineExecutionStepFailure(const Model::SendPipelineExecutionStepFailureRequest& request) const; /** * A Callable wrapper for SendPipelineExecutionStepFailure that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendPipelineExecutionStepFailureOutcomeCallable SendPipelineExecutionStepFailureCallable(const SendPipelineExecutionStepFailureRequestT& request) const { return SubmitCallable(&SageMakerClient::SendPipelineExecutionStepFailure, request); } /** * An Async wrapper for SendPipelineExecutionStepFailure that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendPipelineExecutionStepFailureAsync(const SendPipelineExecutionStepFailureRequestT& request, const SendPipelineExecutionStepFailureResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::SendPipelineExecutionStepFailure, request, handler, context); } /** *

Notifies the pipeline that the execution of a callback step succeeded and * provides a list of the step's output parameters. When a callback step is run, * the pipeline generates a callback token and includes the token in a message sent * to Amazon Simple Queue Service (Amazon SQS).

See Also:

AWS * API Reference

*/ virtual Model::SendPipelineExecutionStepSuccessOutcome SendPipelineExecutionStepSuccess(const Model::SendPipelineExecutionStepSuccessRequest& request) const; /** * A Callable wrapper for SendPipelineExecutionStepSuccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SendPipelineExecutionStepSuccessOutcomeCallable SendPipelineExecutionStepSuccessCallable(const SendPipelineExecutionStepSuccessRequestT& request) const { return SubmitCallable(&SageMakerClient::SendPipelineExecutionStepSuccess, request); } /** * An Async wrapper for SendPipelineExecutionStepSuccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SendPipelineExecutionStepSuccessAsync(const SendPipelineExecutionStepSuccessRequestT& request, const SendPipelineExecutionStepSuccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::SendPipelineExecutionStepSuccess, request, handler, context); } /** *

Starts a stage in an edge deployment plan.

See Also:

AWS * API Reference

*/ virtual Model::StartEdgeDeploymentStageOutcome StartEdgeDeploymentStage(const Model::StartEdgeDeploymentStageRequest& request) const; /** * A Callable wrapper for StartEdgeDeploymentStage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartEdgeDeploymentStageOutcomeCallable StartEdgeDeploymentStageCallable(const StartEdgeDeploymentStageRequestT& request) const { return SubmitCallable(&SageMakerClient::StartEdgeDeploymentStage, request); } /** * An Async wrapper for StartEdgeDeploymentStage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartEdgeDeploymentStageAsync(const StartEdgeDeploymentStageRequestT& request, const StartEdgeDeploymentStageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StartEdgeDeploymentStage, request, handler, context); } /** *

Starts an inference experiment.

See Also:

AWS * API Reference

*/ virtual Model::StartInferenceExperimentOutcome StartInferenceExperiment(const Model::StartInferenceExperimentRequest& request) const; /** * A Callable wrapper for StartInferenceExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartInferenceExperimentOutcomeCallable StartInferenceExperimentCallable(const StartInferenceExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::StartInferenceExperiment, request); } /** * An Async wrapper for StartInferenceExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartInferenceExperimentAsync(const StartInferenceExperimentRequestT& request, const StartInferenceExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StartInferenceExperiment, request, handler, context); } /** *

Starts a previously stopped monitoring schedule.

By default, * when you successfully create a new schedule, the status of a monitoring schedule * is scheduled.

See Also:

AWS * API Reference

*/ virtual Model::StartMonitoringScheduleOutcome StartMonitoringSchedule(const Model::StartMonitoringScheduleRequest& request) const; /** * A Callable wrapper for StartMonitoringSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartMonitoringScheduleOutcomeCallable StartMonitoringScheduleCallable(const StartMonitoringScheduleRequestT& request) const { return SubmitCallable(&SageMakerClient::StartMonitoringSchedule, request); } /** * An Async wrapper for StartMonitoringSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartMonitoringScheduleAsync(const StartMonitoringScheduleRequestT& request, const StartMonitoringScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StartMonitoringSchedule, request, handler, context); } /** *

Launches an ML compute instance with the latest version of the libraries and * attaches your ML storage volume. After configuring the notebook instance, * SageMaker sets the notebook instance status to InService. A * notebook instance's status must be InService before you can connect * to your Jupyter notebook.

See Also:

AWS * API Reference

*/ virtual Model::StartNotebookInstanceOutcome StartNotebookInstance(const Model::StartNotebookInstanceRequest& request) const; /** * A Callable wrapper for StartNotebookInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartNotebookInstanceOutcomeCallable StartNotebookInstanceCallable(const StartNotebookInstanceRequestT& request) const { return SubmitCallable(&SageMakerClient::StartNotebookInstance, request); } /** * An Async wrapper for StartNotebookInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartNotebookInstanceAsync(const StartNotebookInstanceRequestT& request, const StartNotebookInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StartNotebookInstance, request, handler, context); } /** *

Starts a pipeline execution.

See Also:

AWS * API Reference

*/ virtual Model::StartPipelineExecutionOutcome StartPipelineExecution(const Model::StartPipelineExecutionRequest& request) const; /** * A Callable wrapper for StartPipelineExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartPipelineExecutionOutcomeCallable StartPipelineExecutionCallable(const StartPipelineExecutionRequestT& request) const { return SubmitCallable(&SageMakerClient::StartPipelineExecution, request); } /** * An Async wrapper for StartPipelineExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartPipelineExecutionAsync(const StartPipelineExecutionRequestT& request, const StartPipelineExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StartPipelineExecution, request, handler, context); } /** *

A method for forcing a running job to shut down.

See Also:

* AWS * API Reference

*/ virtual Model::StopAutoMLJobOutcome StopAutoMLJob(const Model::StopAutoMLJobRequest& request) const; /** * A Callable wrapper for StopAutoMLJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopAutoMLJobOutcomeCallable StopAutoMLJobCallable(const StopAutoMLJobRequestT& request) const { return SubmitCallable(&SageMakerClient::StopAutoMLJob, request); } /** * An Async wrapper for StopAutoMLJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopAutoMLJobAsync(const StopAutoMLJobRequestT& request, const StopAutoMLJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopAutoMLJob, request, handler, context); } /** *

Stops a model compilation job.

To stop a job, Amazon SageMaker sends * the algorithm the SIGTERM signal. This gracefully shuts the job down. If the job * hasn't stopped, it sends the SIGKILL signal.

When it receives a * StopCompilationJob request, Amazon SageMaker changes the * CompilationJobStatus of the job to Stopping. After * Amazon SageMaker stops the job, it sets the CompilationJobStatus to * Stopped.

See Also:

AWS * API Reference

*/ virtual Model::StopCompilationJobOutcome StopCompilationJob(const Model::StopCompilationJobRequest& request) const; /** * A Callable wrapper for StopCompilationJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopCompilationJobOutcomeCallable StopCompilationJobCallable(const StopCompilationJobRequestT& request) const { return SubmitCallable(&SageMakerClient::StopCompilationJob, request); } /** * An Async wrapper for StopCompilationJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopCompilationJobAsync(const StopCompilationJobRequestT& request, const StopCompilationJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopCompilationJob, request, handler, context); } /** *

Stops a stage in an edge deployment plan.

See Also:

AWS * API Reference

*/ virtual Model::StopEdgeDeploymentStageOutcome StopEdgeDeploymentStage(const Model::StopEdgeDeploymentStageRequest& request) const; /** * A Callable wrapper for StopEdgeDeploymentStage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopEdgeDeploymentStageOutcomeCallable StopEdgeDeploymentStageCallable(const StopEdgeDeploymentStageRequestT& request) const { return SubmitCallable(&SageMakerClient::StopEdgeDeploymentStage, request); } /** * An Async wrapper for StopEdgeDeploymentStage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopEdgeDeploymentStageAsync(const StopEdgeDeploymentStageRequestT& request, const StopEdgeDeploymentStageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopEdgeDeploymentStage, request, handler, context); } /** *

Request to stop an edge packaging job.

See Also:

AWS * API Reference

*/ virtual Model::StopEdgePackagingJobOutcome StopEdgePackagingJob(const Model::StopEdgePackagingJobRequest& request) const; /** * A Callable wrapper for StopEdgePackagingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopEdgePackagingJobOutcomeCallable StopEdgePackagingJobCallable(const StopEdgePackagingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::StopEdgePackagingJob, request); } /** * An Async wrapper for StopEdgePackagingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopEdgePackagingJobAsync(const StopEdgePackagingJobRequestT& request, const StopEdgePackagingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopEdgePackagingJob, request, handler, context); } /** *

Stops a running hyperparameter tuning job and all running training jobs that * the tuning job launched.

All model artifacts output from the training * jobs are stored in Amazon Simple Storage Service (Amazon S3). All data that the * training jobs write to Amazon CloudWatch Logs are still available in CloudWatch. * After the tuning job moves to the Stopped state, it releases all * reserved resources for the tuning job.

See Also:

AWS * API Reference

*/ virtual Model::StopHyperParameterTuningJobOutcome StopHyperParameterTuningJob(const Model::StopHyperParameterTuningJobRequest& request) const; /** * A Callable wrapper for StopHyperParameterTuningJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopHyperParameterTuningJobOutcomeCallable StopHyperParameterTuningJobCallable(const StopHyperParameterTuningJobRequestT& request) const { return SubmitCallable(&SageMakerClient::StopHyperParameterTuningJob, request); } /** * An Async wrapper for StopHyperParameterTuningJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopHyperParameterTuningJobAsync(const StopHyperParameterTuningJobRequestT& request, const StopHyperParameterTuningJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopHyperParameterTuningJob, request, handler, context); } /** *

Stops an inference experiment.

See Also:

AWS * API Reference

*/ virtual Model::StopInferenceExperimentOutcome StopInferenceExperiment(const Model::StopInferenceExperimentRequest& request) const; /** * A Callable wrapper for StopInferenceExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopInferenceExperimentOutcomeCallable StopInferenceExperimentCallable(const StopInferenceExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::StopInferenceExperiment, request); } /** * An Async wrapper for StopInferenceExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopInferenceExperimentAsync(const StopInferenceExperimentRequestT& request, const StopInferenceExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopInferenceExperiment, request, handler, context); } /** *

Stops an Inference Recommender job.

See Also:

AWS * API Reference

*/ virtual Model::StopInferenceRecommendationsJobOutcome StopInferenceRecommendationsJob(const Model::StopInferenceRecommendationsJobRequest& request) const; /** * A Callable wrapper for StopInferenceRecommendationsJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopInferenceRecommendationsJobOutcomeCallable StopInferenceRecommendationsJobCallable(const StopInferenceRecommendationsJobRequestT& request) const { return SubmitCallable(&SageMakerClient::StopInferenceRecommendationsJob, request); } /** * An Async wrapper for StopInferenceRecommendationsJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopInferenceRecommendationsJobAsync(const StopInferenceRecommendationsJobRequestT& request, const StopInferenceRecommendationsJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopInferenceRecommendationsJob, request, handler, context); } /** *

Stops a running labeling job. A job that is stopped cannot be restarted. Any * results obtained before the job is stopped are placed in the Amazon S3 output * bucket.

See Also:

AWS * API Reference

*/ virtual Model::StopLabelingJobOutcome StopLabelingJob(const Model::StopLabelingJobRequest& request) const; /** * A Callable wrapper for StopLabelingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopLabelingJobOutcomeCallable StopLabelingJobCallable(const StopLabelingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::StopLabelingJob, request); } /** * An Async wrapper for StopLabelingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopLabelingJobAsync(const StopLabelingJobRequestT& request, const StopLabelingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopLabelingJob, request, handler, context); } /** *

Stops a previously started monitoring schedule.

See Also:

AWS * API Reference

*/ virtual Model::StopMonitoringScheduleOutcome StopMonitoringSchedule(const Model::StopMonitoringScheduleRequest& request) const; /** * A Callable wrapper for StopMonitoringSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopMonitoringScheduleOutcomeCallable StopMonitoringScheduleCallable(const StopMonitoringScheduleRequestT& request) const { return SubmitCallable(&SageMakerClient::StopMonitoringSchedule, request); } /** * An Async wrapper for StopMonitoringSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopMonitoringScheduleAsync(const StopMonitoringScheduleRequestT& request, const StopMonitoringScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopMonitoringSchedule, request, handler, context); } /** *

Terminates the ML compute instance. Before terminating the instance, * SageMaker disconnects the ML storage volume from it. SageMaker preserves the ML * storage volume. SageMaker stops charging you for the ML compute instance when * you call StopNotebookInstance.

To access data on the ML * storage volume for a notebook instance that has been terminated, call the * StartNotebookInstance API. StartNotebookInstance * launches another ML compute instance, configures it, and attaches the preserved * ML storage volume so you can continue your work.

See Also:

AWS * API Reference

*/ virtual Model::StopNotebookInstanceOutcome StopNotebookInstance(const Model::StopNotebookInstanceRequest& request) const; /** * A Callable wrapper for StopNotebookInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopNotebookInstanceOutcomeCallable StopNotebookInstanceCallable(const StopNotebookInstanceRequestT& request) const { return SubmitCallable(&SageMakerClient::StopNotebookInstance, request); } /** * An Async wrapper for StopNotebookInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopNotebookInstanceAsync(const StopNotebookInstanceRequestT& request, const StopNotebookInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopNotebookInstance, request, handler, context); } /** *

Stops a pipeline execution.

Callback Step

A pipeline * execution won't stop while a callback step is running. When you call * StopPipelineExecution on a pipeline execution with a running * callback step, SageMaker Pipelines sends an additional Amazon SQS message to the * specified SQS queue. The body of the SQS message contains a "Status" field which * is set to "Stopping".

You should add logic to your Amazon SQS message * consumer to take any needed action (for example, resource cleanup) upon receipt * of the message followed by a call to * SendPipelineExecutionStepSuccess or * SendPipelineExecutionStepFailure.

Only when SageMaker * Pipelines receives one of these calls will it stop the pipeline execution.

*

Lambda Step

A pipeline execution can't be stopped while a * lambda step is running because the Lambda function invoked by the lambda step * can't be stopped. If you attempt to stop the execution while the Lambda function * is running, the pipeline waits for the Lambda function to finish or until the * timeout is hit, whichever occurs first, and then stops. If the Lambda function * finishes, the pipeline execution status is Stopped. If the timeout * is hit the pipeline execution status is Failed.

See * Also:

AWS * API Reference

*/ virtual Model::StopPipelineExecutionOutcome StopPipelineExecution(const Model::StopPipelineExecutionRequest& request) const; /** * A Callable wrapper for StopPipelineExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopPipelineExecutionOutcomeCallable StopPipelineExecutionCallable(const StopPipelineExecutionRequestT& request) const { return SubmitCallable(&SageMakerClient::StopPipelineExecution, request); } /** * An Async wrapper for StopPipelineExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopPipelineExecutionAsync(const StopPipelineExecutionRequestT& request, const StopPipelineExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopPipelineExecution, request, handler, context); } /** *

Stops a processing job.

See Also:

AWS * API Reference

*/ virtual Model::StopProcessingJobOutcome StopProcessingJob(const Model::StopProcessingJobRequest& request) const; /** * A Callable wrapper for StopProcessingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopProcessingJobOutcomeCallable StopProcessingJobCallable(const StopProcessingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::StopProcessingJob, request); } /** * An Async wrapper for StopProcessingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopProcessingJobAsync(const StopProcessingJobRequestT& request, const StopProcessingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopProcessingJob, request, handler, context); } /** *

Stops a training job. To stop a job, SageMaker sends the algorithm the * SIGTERM signal, which delays job termination for 120 seconds. * Algorithms might use this 120-second window to save the model artifacts, so the * results of the training is not lost.

When it receives a * StopTrainingJob request, SageMaker changes the status of the job to * Stopping. After SageMaker stops the job, it sets the status to * Stopped.

See Also:

AWS * API Reference

*/ virtual Model::StopTrainingJobOutcome StopTrainingJob(const Model::StopTrainingJobRequest& request) const; /** * A Callable wrapper for StopTrainingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopTrainingJobOutcomeCallable StopTrainingJobCallable(const StopTrainingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::StopTrainingJob, request); } /** * An Async wrapper for StopTrainingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopTrainingJobAsync(const StopTrainingJobRequestT& request, const StopTrainingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopTrainingJob, request, handler, context); } /** *

Stops a batch transform job.

When Amazon SageMaker receives a * StopTransformJob request, the status of the job changes to * Stopping. After Amazon SageMaker stops the job, the status is set * to Stopped. When you stop a batch transform job before it is * completed, Amazon SageMaker doesn't store the job's output in Amazon * S3.

See Also:

AWS * API Reference

*/ virtual Model::StopTransformJobOutcome StopTransformJob(const Model::StopTransformJobRequest& request) const; /** * A Callable wrapper for StopTransformJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopTransformJobOutcomeCallable StopTransformJobCallable(const StopTransformJobRequestT& request) const { return SubmitCallable(&SageMakerClient::StopTransformJob, request); } /** * An Async wrapper for StopTransformJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopTransformJobAsync(const StopTransformJobRequestT& request, const StopTransformJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::StopTransformJob, request, handler, context); } /** *

Updates an action.

See Also:

AWS * API Reference

*/ virtual Model::UpdateActionOutcome UpdateAction(const Model::UpdateActionRequest& request) const; /** * A Callable wrapper for UpdateAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateActionOutcomeCallable UpdateActionCallable(const UpdateActionRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateAction, request); } /** * An Async wrapper for UpdateAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateActionAsync(const UpdateActionRequestT& request, const UpdateActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateAction, request, handler, context); } /** *

Updates the properties of an AppImageConfig.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAppImageConfigOutcome UpdateAppImageConfig(const Model::UpdateAppImageConfigRequest& request) const; /** * A Callable wrapper for UpdateAppImageConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAppImageConfigOutcomeCallable UpdateAppImageConfigCallable(const UpdateAppImageConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateAppImageConfig, request); } /** * An Async wrapper for UpdateAppImageConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAppImageConfigAsync(const UpdateAppImageConfigRequestT& request, const UpdateAppImageConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateAppImageConfig, request, handler, context); } /** *

Updates an artifact.

See Also:

AWS * API Reference

*/ virtual Model::UpdateArtifactOutcome UpdateArtifact(const Model::UpdateArtifactRequest& request) const; /** * A Callable wrapper for UpdateArtifact that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateArtifactOutcomeCallable UpdateArtifactCallable(const UpdateArtifactRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateArtifact, request); } /** * An Async wrapper for UpdateArtifact that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateArtifactAsync(const UpdateArtifactRequestT& request, const UpdateArtifactResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateArtifact, request, handler, context); } /** *

Updates the specified Git repository with the specified values.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateCodeRepositoryOutcome UpdateCodeRepository(const Model::UpdateCodeRepositoryRequest& request) const; /** * A Callable wrapper for UpdateCodeRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCodeRepositoryOutcomeCallable UpdateCodeRepositoryCallable(const UpdateCodeRepositoryRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateCodeRepository, request); } /** * An Async wrapper for UpdateCodeRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCodeRepositoryAsync(const UpdateCodeRepositoryRequestT& request, const UpdateCodeRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateCodeRepository, request, handler, context); } /** *

Updates a context.

See Also:

AWS * API Reference

*/ virtual Model::UpdateContextOutcome UpdateContext(const Model::UpdateContextRequest& request) const; /** * A Callable wrapper for UpdateContext that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateContextOutcomeCallable UpdateContextCallable(const UpdateContextRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateContext, request); } /** * An Async wrapper for UpdateContext that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateContextAsync(const UpdateContextRequestT& request, const UpdateContextResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateContext, request, handler, context); } /** *

Updates a fleet of devices.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDeviceFleetOutcome UpdateDeviceFleet(const Model::UpdateDeviceFleetRequest& request) const; /** * A Callable wrapper for UpdateDeviceFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDeviceFleetOutcomeCallable UpdateDeviceFleetCallable(const UpdateDeviceFleetRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateDeviceFleet, request); } /** * An Async wrapper for UpdateDeviceFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDeviceFleetAsync(const UpdateDeviceFleetRequestT& request, const UpdateDeviceFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateDeviceFleet, request, handler, context); } /** *

Updates one or more devices in a fleet.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDevicesOutcome UpdateDevices(const Model::UpdateDevicesRequest& request) const; /** * A Callable wrapper for UpdateDevices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDevicesOutcomeCallable UpdateDevicesCallable(const UpdateDevicesRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateDevices, request); } /** * An Async wrapper for UpdateDevices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDevicesAsync(const UpdateDevicesRequestT& request, const UpdateDevicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateDevices, request, handler, context); } /** *

Updates the default settings for new user profiles in the * domain.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDomainOutcome UpdateDomain(const Model::UpdateDomainRequest& request) const; /** * A Callable wrapper for UpdateDomain that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDomainOutcomeCallable UpdateDomainCallable(const UpdateDomainRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateDomain, request); } /** * An Async wrapper for UpdateDomain that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDomainAsync(const UpdateDomainRequestT& request, const UpdateDomainResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateDomain, request, handler, context); } /** *

Deploys the new EndpointConfig specified in the request, * switches to using newly created endpoint, and then deletes resources provisioned * for the endpoint using the previous EndpointConfig (there is no * availability loss).

When SageMaker receives the request, it sets the * endpoint status to Updating. After updating the endpoint, it sets * the status to InService. To check the status of an endpoint, use * the DescribeEndpoint * API.

You must not delete an EndpointConfig in use by * an endpoint that is live or while the UpdateEndpoint or * CreateEndpoint operations are being performed on the endpoint. To * update an endpoint, you must create a new EndpointConfig.

If * you delete the EndpointConfig of an endpoint that is active or * being created or updated you may lose visibility into the instance type the * endpoint is using. The endpoint must be deleted in order to stop incurring * charges.

See Also:

AWS * API Reference

*/ virtual Model::UpdateEndpointOutcome UpdateEndpoint(const Model::UpdateEndpointRequest& request) const; /** * A Callable wrapper for UpdateEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEndpointOutcomeCallable UpdateEndpointCallable(const UpdateEndpointRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateEndpoint, request); } /** * An Async wrapper for UpdateEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEndpointAsync(const UpdateEndpointRequestT& request, const UpdateEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateEndpoint, request, handler, context); } /** *

Updates variant weight of one or more variants associated with an existing * endpoint, or capacity of one variant associated with an existing endpoint. When * it receives the request, SageMaker sets the endpoint status to * Updating. After updating the endpoint, it sets the status to * InService. To check the status of an endpoint, use the DescribeEndpoint * API.

See Also:

AWS * API Reference

*/ virtual Model::UpdateEndpointWeightsAndCapacitiesOutcome UpdateEndpointWeightsAndCapacities(const Model::UpdateEndpointWeightsAndCapacitiesRequest& request) const; /** * A Callable wrapper for UpdateEndpointWeightsAndCapacities that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEndpointWeightsAndCapacitiesOutcomeCallable UpdateEndpointWeightsAndCapacitiesCallable(const UpdateEndpointWeightsAndCapacitiesRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateEndpointWeightsAndCapacities, request); } /** * An Async wrapper for UpdateEndpointWeightsAndCapacities that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEndpointWeightsAndCapacitiesAsync(const UpdateEndpointWeightsAndCapacitiesRequestT& request, const UpdateEndpointWeightsAndCapacitiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateEndpointWeightsAndCapacities, request, handler, context); } /** *

Adds, updates, or removes the description of an experiment. Updates the * display name of an experiment.

See Also:

AWS * API Reference

*/ virtual Model::UpdateExperimentOutcome UpdateExperiment(const Model::UpdateExperimentRequest& request) const; /** * A Callable wrapper for UpdateExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateExperimentOutcomeCallable UpdateExperimentCallable(const UpdateExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateExperiment, request); } /** * An Async wrapper for UpdateExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateExperimentAsync(const UpdateExperimentRequestT& request, const UpdateExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateExperiment, request, handler, context); } /** *

Updates the feature group by either adding features or updating the online * store configuration. Use one of the following request parameters at a time while * using the UpdateFeatureGroup API.

You can add features for * your feature group using the FeatureAdditions request parameter. * Features cannot be removed from a feature group.

You can update the * online store configuration by using the OnlineStoreConfig request * parameter. If a TtlDuration is specified, the default * TtlDuration applies for all records added to the feature group * after the feature group is updated. If a record level * TtlDuration exists from using the PutRecord API, the * record level TtlDuration applies to that record instead of the * default TtlDuration.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFeatureGroupOutcome UpdateFeatureGroup(const Model::UpdateFeatureGroupRequest& request) const; /** * A Callable wrapper for UpdateFeatureGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFeatureGroupOutcomeCallable UpdateFeatureGroupCallable(const UpdateFeatureGroupRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateFeatureGroup, request); } /** * An Async wrapper for UpdateFeatureGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFeatureGroupAsync(const UpdateFeatureGroupRequestT& request, const UpdateFeatureGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateFeatureGroup, request, handler, context); } /** *

Updates the description and parameters of the feature group.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateFeatureMetadataOutcome UpdateFeatureMetadata(const Model::UpdateFeatureMetadataRequest& request) const; /** * A Callable wrapper for UpdateFeatureMetadata that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFeatureMetadataOutcomeCallable UpdateFeatureMetadataCallable(const UpdateFeatureMetadataRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateFeatureMetadata, request); } /** * An Async wrapper for UpdateFeatureMetadata that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFeatureMetadataAsync(const UpdateFeatureMetadataRequestT& request, const UpdateFeatureMetadataResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateFeatureMetadata, request, handler, context); } /** *

Update a hub.

Hub APIs are only callable through SageMaker * Studio.

See Also:

AWS * API Reference

*/ virtual Model::UpdateHubOutcome UpdateHub(const Model::UpdateHubRequest& request) const; /** * A Callable wrapper for UpdateHub that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateHubOutcomeCallable UpdateHubCallable(const UpdateHubRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateHub, request); } /** * An Async wrapper for UpdateHub that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateHubAsync(const UpdateHubRequestT& request, const UpdateHubResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateHub, request, handler, context); } /** *

Updates the properties of a SageMaker image. To change the image's tags, use * the AddTags * and DeleteTags * APIs.

See Also:

AWS * API Reference

*/ virtual Model::UpdateImageOutcome UpdateImage(const Model::UpdateImageRequest& request) const; /** * A Callable wrapper for UpdateImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateImageOutcomeCallable UpdateImageCallable(const UpdateImageRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateImage, request); } /** * An Async wrapper for UpdateImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateImageAsync(const UpdateImageRequestT& request, const UpdateImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateImage, request, handler, context); } /** *

Updates the properties of a SageMaker image version.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateImageVersionOutcome UpdateImageVersion(const Model::UpdateImageVersionRequest& request) const; /** * A Callable wrapper for UpdateImageVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateImageVersionOutcomeCallable UpdateImageVersionCallable(const UpdateImageVersionRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateImageVersion, request); } /** * An Async wrapper for UpdateImageVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateImageVersionAsync(const UpdateImageVersionRequestT& request, const UpdateImageVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateImageVersion, request, handler, context); } /** *

Updates an inference experiment that you created. The status of the * inference experiment has to be either Created, * Running. For more information on the status of an inference * experiment, see DescribeInferenceExperiment. *

See Also:

AWS * API Reference

*/ virtual Model::UpdateInferenceExperimentOutcome UpdateInferenceExperiment(const Model::UpdateInferenceExperimentRequest& request) const; /** * A Callable wrapper for UpdateInferenceExperiment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateInferenceExperimentOutcomeCallable UpdateInferenceExperimentCallable(const UpdateInferenceExperimentRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateInferenceExperiment, request); } /** * An Async wrapper for UpdateInferenceExperiment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateInferenceExperimentAsync(const UpdateInferenceExperimentRequestT& request, const UpdateInferenceExperimentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateInferenceExperiment, request, handler, context); } /** *

Update an Amazon SageMaker Model Card.

You cannot update * both model card content and model card status in a single call.

*

See Also:

AWS * API Reference

*/ virtual Model::UpdateModelCardOutcome UpdateModelCard(const Model::UpdateModelCardRequest& request) const; /** * A Callable wrapper for UpdateModelCard that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateModelCardOutcomeCallable UpdateModelCardCallable(const UpdateModelCardRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateModelCard, request); } /** * An Async wrapper for UpdateModelCard that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateModelCardAsync(const UpdateModelCardRequestT& request, const UpdateModelCardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateModelCard, request, handler, context); } /** *

Updates a versioned model.

See Also:

AWS * API Reference

*/ virtual Model::UpdateModelPackageOutcome UpdateModelPackage(const Model::UpdateModelPackageRequest& request) const; /** * A Callable wrapper for UpdateModelPackage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateModelPackageOutcomeCallable UpdateModelPackageCallable(const UpdateModelPackageRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateModelPackage, request); } /** * An Async wrapper for UpdateModelPackage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateModelPackageAsync(const UpdateModelPackageRequestT& request, const UpdateModelPackageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateModelPackage, request, handler, context); } /** *

Update the parameters of a model monitor alert.

See Also:

AWS * API Reference

*/ virtual Model::UpdateMonitoringAlertOutcome UpdateMonitoringAlert(const Model::UpdateMonitoringAlertRequest& request) const; /** * A Callable wrapper for UpdateMonitoringAlert that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateMonitoringAlertOutcomeCallable UpdateMonitoringAlertCallable(const UpdateMonitoringAlertRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateMonitoringAlert, request); } /** * An Async wrapper for UpdateMonitoringAlert that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateMonitoringAlertAsync(const UpdateMonitoringAlertRequestT& request, const UpdateMonitoringAlertResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateMonitoringAlert, request, handler, context); } /** *

Updates a previously created schedule.

See Also:

AWS * API Reference

*/ virtual Model::UpdateMonitoringScheduleOutcome UpdateMonitoringSchedule(const Model::UpdateMonitoringScheduleRequest& request) const; /** * A Callable wrapper for UpdateMonitoringSchedule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateMonitoringScheduleOutcomeCallable UpdateMonitoringScheduleCallable(const UpdateMonitoringScheduleRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateMonitoringSchedule, request); } /** * An Async wrapper for UpdateMonitoringSchedule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateMonitoringScheduleAsync(const UpdateMonitoringScheduleRequestT& request, const UpdateMonitoringScheduleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateMonitoringSchedule, request, handler, context); } /** *

Updates a notebook instance. NotebookInstance updates include upgrading or * downgrading the ML compute instance used for your notebook instance to * accommodate changes in your workload requirements.

See Also:

AWS * API Reference

*/ virtual Model::UpdateNotebookInstanceOutcome UpdateNotebookInstance(const Model::UpdateNotebookInstanceRequest& request) const; /** * A Callable wrapper for UpdateNotebookInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateNotebookInstanceOutcomeCallable UpdateNotebookInstanceCallable(const UpdateNotebookInstanceRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateNotebookInstance, request); } /** * An Async wrapper for UpdateNotebookInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateNotebookInstanceAsync(const UpdateNotebookInstanceRequestT& request, const UpdateNotebookInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateNotebookInstance, request, handler, context); } /** *

Updates a notebook instance lifecycle configuration created with the CreateNotebookInstanceLifecycleConfig * API.

See Also:

AWS * API Reference

*/ virtual Model::UpdateNotebookInstanceLifecycleConfigOutcome UpdateNotebookInstanceLifecycleConfig(const Model::UpdateNotebookInstanceLifecycleConfigRequest& request) const; /** * A Callable wrapper for UpdateNotebookInstanceLifecycleConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateNotebookInstanceLifecycleConfigOutcomeCallable UpdateNotebookInstanceLifecycleConfigCallable(const UpdateNotebookInstanceLifecycleConfigRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateNotebookInstanceLifecycleConfig, request); } /** * An Async wrapper for UpdateNotebookInstanceLifecycleConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateNotebookInstanceLifecycleConfigAsync(const UpdateNotebookInstanceLifecycleConfigRequestT& request, const UpdateNotebookInstanceLifecycleConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateNotebookInstanceLifecycleConfig, request, handler, context); } /** *

Updates a pipeline.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePipelineOutcome UpdatePipeline(const Model::UpdatePipelineRequest& request) const; /** * A Callable wrapper for UpdatePipeline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePipelineOutcomeCallable UpdatePipelineCallable(const UpdatePipelineRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdatePipeline, request); } /** * An Async wrapper for UpdatePipeline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePipelineAsync(const UpdatePipelineRequestT& request, const UpdatePipelineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdatePipeline, request, handler, context); } /** *

Updates a pipeline execution.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePipelineExecutionOutcome UpdatePipelineExecution(const Model::UpdatePipelineExecutionRequest& request) const; /** * A Callable wrapper for UpdatePipelineExecution that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePipelineExecutionOutcomeCallable UpdatePipelineExecutionCallable(const UpdatePipelineExecutionRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdatePipelineExecution, request); } /** * An Async wrapper for UpdatePipelineExecution that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePipelineExecutionAsync(const UpdatePipelineExecutionRequestT& request, const UpdatePipelineExecutionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdatePipelineExecution, request, handler, context); } /** *

Updates a machine learning (ML) project that is created from a template that * sets up an ML pipeline from training to deploying an approved model.

*

You must not update a project that is in use. If you update the * ServiceCatalogProvisioningUpdateDetails of a project that is active * or being created, or updated, you may lose resources already created by the * project.

See Also:

AWS * API Reference

*/ virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const; /** * A Callable wrapper for UpdateProject that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateProject, request); } /** * An Async wrapper for UpdateProject that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateProject, request, handler, context); } /** *

Updates the settings of a space.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSpaceOutcome UpdateSpace(const Model::UpdateSpaceRequest& request) const; /** * A Callable wrapper for UpdateSpace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSpaceOutcomeCallable UpdateSpaceCallable(const UpdateSpaceRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateSpace, request); } /** * An Async wrapper for UpdateSpace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSpaceAsync(const UpdateSpaceRequestT& request, const UpdateSpaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateSpace, request, handler, context); } /** *

Update a model training job to request a new Debugger profiling configuration * or to change warm pool retention length.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTrainingJobOutcome UpdateTrainingJob(const Model::UpdateTrainingJobRequest& request) const; /** * A Callable wrapper for UpdateTrainingJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTrainingJobOutcomeCallable UpdateTrainingJobCallable(const UpdateTrainingJobRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateTrainingJob, request); } /** * An Async wrapper for UpdateTrainingJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTrainingJobAsync(const UpdateTrainingJobRequestT& request, const UpdateTrainingJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateTrainingJob, request, handler, context); } /** *

Updates the display name of a trial.

See Also:

AWS * API Reference

*/ virtual Model::UpdateTrialOutcome UpdateTrial(const Model::UpdateTrialRequest& request) const; /** * A Callable wrapper for UpdateTrial that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTrialOutcomeCallable UpdateTrialCallable(const UpdateTrialRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateTrial, request); } /** * An Async wrapper for UpdateTrial that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTrialAsync(const UpdateTrialRequestT& request, const UpdateTrialResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateTrial, request, handler, context); } /** *

Updates one or more properties of a trial component.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateTrialComponentOutcome UpdateTrialComponent(const Model::UpdateTrialComponentRequest& request) const; /** * A Callable wrapper for UpdateTrialComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTrialComponentOutcomeCallable UpdateTrialComponentCallable(const UpdateTrialComponentRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateTrialComponent, request); } /** * An Async wrapper for UpdateTrialComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTrialComponentAsync(const UpdateTrialComponentRequestT& request, const UpdateTrialComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateTrialComponent, request, handler, context); } /** *

Updates a user profile.

See Also:

AWS * API Reference

*/ virtual Model::UpdateUserProfileOutcome UpdateUserProfile(const Model::UpdateUserProfileRequest& request) const; /** * A Callable wrapper for UpdateUserProfile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateUserProfileOutcomeCallable UpdateUserProfileCallable(const UpdateUserProfileRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateUserProfile, request); } /** * An Async wrapper for UpdateUserProfile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateUserProfileAsync(const UpdateUserProfileRequestT& request, const UpdateUserProfileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateUserProfile, request, handler, context); } /** *

Use this operation to update your workforce. You can use this operation to * require that workers use specific IP addresses to work on tasks and to update * your OpenID Connect (OIDC) Identity Provider (IdP) workforce configuration.

*

The worker portal is now supported in VPC and public internet.

Use * SourceIpConfig to restrict worker access to tasks to a specific * range of IP addresses. You specify allowed IP addresses by creating a list of up * to ten CIDRs. * By default, a workforce isn't restricted to specific IP addresses. If you * specify a range of IP addresses, workers who attempt to access tasks using any * IP address outside the specified range are denied and get a Not * Found error message on the worker portal.

To restrict access to * all the workers in public internet, add the SourceIpConfig CIDR * value as "10.0.0.0/16".

Amazon SageMaker does not support * Source Ip restriction for worker portals in VPC.

Use * OidcConfig to update the configuration of a workforce created using * your own OIDC IdP.

You can only update your OIDC IdP * configuration when there are no work teams associated with your workforce. You * can delete work teams using the DeleteWorkteam * operation.

After restricting access to a range of IP * addresses or updating your OIDC IdP configuration with this operation, you can * view details about your update workforce using the DescribeWorkforce * operation.

This operation only applies to private * workforces.

See Also:

AWS * API Reference

*/ virtual Model::UpdateWorkforceOutcome UpdateWorkforce(const Model::UpdateWorkforceRequest& request) const; /** * A Callable wrapper for UpdateWorkforce that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateWorkforceOutcomeCallable UpdateWorkforceCallable(const UpdateWorkforceRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateWorkforce, request); } /** * An Async wrapper for UpdateWorkforce that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateWorkforceAsync(const UpdateWorkforceRequestT& request, const UpdateWorkforceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateWorkforce, request, handler, context); } /** *

Updates an existing work team with new member definitions or * description.

See Also:

AWS * API Reference

*/ virtual Model::UpdateWorkteamOutcome UpdateWorkteam(const Model::UpdateWorkteamRequest& request) const; /** * A Callable wrapper for UpdateWorkteam that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateWorkteamOutcomeCallable UpdateWorkteamCallable(const UpdateWorkteamRequestT& request) const { return SubmitCallable(&SageMakerClient::UpdateWorkteam, request); } /** * An Async wrapper for UpdateWorkteam that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateWorkteamAsync(const UpdateWorkteamRequestT& request, const UpdateWorkteamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&SageMakerClient::UpdateWorkteam, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const SageMakerClientConfiguration& clientConfiguration); SageMakerClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace SageMaker } // namespace Aws