@aws-sdk/client-sagemaker 3.36.0 → 3.39.0

package/dist-types/ts3.4/commands/CreatePipelineCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreatePipelineCommandInput extends CreatePipelineRequest {
 }
 export interface CreatePipelineCommandOutput extends CreatePipelineResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a pipeline using a JSON pipeline definition.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreatePipelineCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreatePipelineCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreatePipelineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreatePipelineCommandInput} for command's `input` shape.
- * @see {@link CreatePipelineCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreatePipelineCommand extends $Command<CreatePipelineCommandInput, CreatePipelineCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreatePipelineCommandInput;
     constructor(input: CreatePipelineCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePipelineCommandInput, CreatePipelineCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreatePresignedDomainUrlCommand.d.ts

@@ -6,45 +6,11 @@ export interface CreatePresignedDomainUrlCommandInput extends CreatePresignedDom
 }
 export interface CreatePresignedDomainUrlCommandOutput extends CreatePresignedDomainUrlResponse, __MetadataBearer {
 }
-/**
- * <p>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.
- *    </p>
- *          <p>The IAM role or user used to call 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.</p>
- *          <p>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 <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/studio-interface-endpoint.html">Connect to SageMaker Studio Through an Interface VPC Endpoint</a>
- *          .</p>
- *          <note>
- *             <p>The URL that you get from a call to <code>CreatePresignedDomainUrl</code> has a default timeout of 5 minutes. You can configure this value using <code>ExpiresInSeconds</code>. If you try to use the URL after the timeout limit expires, you
- *           are directed to the Amazon Web Services console sign-in page.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreatePresignedDomainUrlCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreatePresignedDomainUrlCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreatePresignedDomainUrlCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreatePresignedDomainUrlCommandInput} for command's `input` shape.
- * @see {@link CreatePresignedDomainUrlCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreatePresignedDomainUrlCommand extends $Command<CreatePresignedDomainUrlCommandInput, CreatePresignedDomainUrlCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreatePresignedDomainUrlCommandInput;
     constructor(input: CreatePresignedDomainUrlCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePresignedDomainUrlCommandInput, CreatePresignedDomainUrlCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreatePresignedNotebookInstanceUrlCommand.d.ts

@@ -6,46 +6,11 @@ export interface CreatePresignedNotebookInstanceUrlCommandInput extends CreatePr
 }
 export interface CreatePresignedNotebookInstanceUrlCommandOutput extends CreatePresignedNotebookInstanceUrlOutput, __MetadataBearer {
 }
-/**
- * <p>Returns a URL that you can use to connect to the Jupyter server from a notebook
- *             instance. In the Amazon SageMaker console, when you choose <code>Open</code> next to a notebook
- *             instance, Amazon 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.</p>
- *         <p> 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.</p>
- *         <p>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 <code>NotIpAddress</code> condition operator and the
- *                 <code>aws:SourceIP</code> condition context key to specify the list of IP addresses
- *             that you want to have access to the notebook instance. For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/security_iam_id-based-policy-examples.html#nbi-ip-filter">Limit Access to a Notebook Instance by IP Address</a>.</p>
- *         <note>
- *             <p>The URL that you get from a call to <a>CreatePresignedNotebookInstanceUrl</a> 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.</p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreatePresignedNotebookInstanceUrlCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreatePresignedNotebookInstanceUrlCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreatePresignedNotebookInstanceUrlCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreatePresignedNotebookInstanceUrlCommandInput} for command's `input` shape.
- * @see {@link CreatePresignedNotebookInstanceUrlCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreatePresignedNotebookInstanceUrlCommand extends $Command<CreatePresignedNotebookInstanceUrlCommandInput, CreatePresignedNotebookInstanceUrlCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreatePresignedNotebookInstanceUrlCommandInput;
     constructor(input: CreatePresignedNotebookInstanceUrlCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePresignedNotebookInstanceUrlCommandInput, CreatePresignedNotebookInstanceUrlCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateProcessingJobCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreateProcessingJobCommandInput extends CreateProcessingJobRequ
 }
 export interface CreateProcessingJobCommandOutput extends CreateProcessingJobResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a processing job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateProcessingJobCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateProcessingJobCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateProcessingJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateProcessingJobCommandInput} for command's `input` shape.
- * @see {@link CreateProcessingJobCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateProcessingJobCommand extends $Command<CreateProcessingJobCommandInput, CreateProcessingJobCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateProcessingJobCommandInput;
     constructor(input: CreateProcessingJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateProcessingJobCommandInput, CreateProcessingJobCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateProjectCommand.d.ts

@@ -6,30 +6,11 @@ export interface CreateProjectCommandInput extends CreateProjectInput {
 }
 export interface CreateProjectCommandOutput extends CreateProjectOutput, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateProjectCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateProjectCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateProjectCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateProjectCommandInput} for command's `input` shape.
- * @see {@link CreateProjectCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateProjectCommand extends $Command<CreateProjectCommandInput, CreateProjectCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateProjectCommandInput;
     constructor(input: CreateProjectCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateProjectCommandInput, CreateProjectCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateStudioLifecycleConfigCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreateStudioLifecycleConfigCommandInput extends CreateStudioLif
 }
 export interface CreateStudioLifecycleConfigCommandOutput extends CreateStudioLifecycleConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new Studio Lifecycle Configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateStudioLifecycleConfigCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateStudioLifecycleConfigCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateStudioLifecycleConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateStudioLifecycleConfigCommandInput} for command's `input` shape.
- * @see {@link CreateStudioLifecycleConfigCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateStudioLifecycleConfigCommand extends $Command<CreateStudioLifecycleConfigCommandInput, CreateStudioLifecycleConfigCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateStudioLifecycleConfigCommandInput;
     constructor(input: CreateStudioLifecycleConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateStudioLifecycleConfigCommandInput, CreateStudioLifecycleConfigCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateTrainingJobCommand.d.ts

@@ -6,101 +6,11 @@ export interface CreateTrainingJobCommandInput extends CreateTrainingJobRequest
 }
 export interface CreateTrainingJobCommandOutput extends CreateTrainingJobResponse, __MetadataBearer {
 }
-/**
- * <p>Starts a model training job. After training completes, Amazon SageMaker saves the resulting
- *             model artifacts to an Amazon S3 location that you specify. </p>
- *         <p>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 in a
- *             machine learning service other than Amazon SageMaker, provided that you know how to use them for
- *             inference.
- *         </p>
- *         <p>In the request body, you provide the following: </p>
- *         <ul>
- *             <li>
- *                 <p>
- *                   <code>AlgorithmSpecification</code> - Identifies the training algorithm to
- *                     use.
- *                     </p>
- *             </li>
- *             <li>
- *                 <p>
- *                     <code>HyperParameters</code> - 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 Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html">Algorithms</a>. </p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>InputDataConfig</code> - Describes the training dataset and the Amazon S3,
- *                     EFS, or FSx location where it is stored.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>OutputDataConfig</code> - Identifies the Amazon S3 bucket where you want
- *                     Amazon SageMaker to save the results of model training. </p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>ResourceConfig</code> - Identifies the resources, ML compute
- *                     instances, and ML storage volumes to deploy for model training. In distributed
- *                     training, you specify more than one instance. </p>
- *
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>EnableManagedSpotTraining</code> - Optimize the cost of training machine
- *                     learning models by up to 80% by using Amazon EC2 Spot instances. For more
- *                     information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html">Managed Spot
- *                         Training</a>. </p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>RoleArn</code> - The Amazon Resource Name (ARN) that Amazon SageMaker assumes to perform tasks on
- *                     your behalf during model training.
- *
- *                     You must grant this role the necessary permissions so that Amazon SageMaker can successfully
- *                     complete model training. </p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>StoppingCondition</code> - To help cap training costs, use
- *                         <code>MaxRuntimeInSeconds</code> to set a time limit for training. Use
- *                         <code>MaxWaitTimeInSeconds</code> to specify how long a managed spot
- *                     training job has to complete. </p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>Environment</code> - The environment variables to set in the Docker
- *                     container.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>RetryStrategy</code> - The number of times to retry the job when the job
- *                     fails due to an <code>InternalServerError</code>.</p>
- *             </li>
- *          </ul>
- *         <p> For more information about Amazon SageMaker, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html">How It Works</a>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateTrainingJobCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateTrainingJobCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateTrainingJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrainingJobCommandInput} for command's `input` shape.
- * @see {@link CreateTrainingJobCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTrainingJobCommand extends $Command<CreateTrainingJobCommandInput, CreateTrainingJobCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateTrainingJobCommandInput;
     constructor(input: CreateTrainingJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrainingJobCommandInput, CreateTrainingJobCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateTransformJobCommand.d.ts

@@ -6,63 +6,11 @@ export interface CreateTransformJobCommandInput extends CreateTransformJobReques
 }
 export interface CreateTransformJobCommandOutput extends CreateTransformJobResponse, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- *         <p>To perform batch transformations, you create a transform job and use the data that you
- *             have readily available.</p>
- *         <p>In the request body, you provide the following:</p>
- *         <ul>
- *             <li>
- *                 <p>
- *                   <code>TransformJobName</code> - Identifies the transform job. The name must be
- *                     unique within an Amazon Web Services Region in an Amazon Web Services account.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>ModelName</code> - Identifies the model to use. <code>ModelName</code>
- *                     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 <a>CreateModel</a>.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>TransformInput</code> - Describes the dataset to be transformed and the
- *                     Amazon S3 location where it is stored.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>TransformOutput</code> - Identifies the Amazon S3 location where you want
- *                     Amazon SageMaker to save the results from the transform job.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>TransformResources</code> - Identifies the ML compute instances for the
- *                     transform job.</p>
- *             </li>
- *          </ul>
- *         <p>For more information about how batch transformation works, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html">Batch
- *                 Transform</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateTransformJobCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateTransformJobCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateTransformJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTransformJobCommandInput} for command's `input` shape.
- * @see {@link CreateTransformJobCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTransformJobCommand extends $Command<CreateTransformJobCommandInput, CreateTransformJobCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateTransformJobCommandInput;
     constructor(input: CreateTransformJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransformJobCommandInput, CreateTransformJobCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateTrialCommand.d.ts

@@ -6,39 +6,11 @@ export interface CreateTrialCommandInput extends CreateTrialRequest {
 }
 export interface CreateTrialCommandOutput extends CreateTrialResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an SageMaker <i>trial</i>. A trial is a set of steps called
- *         <i>trial components</i> that produce a machine learning model. A trial is part
- *       of a single SageMaker <i>experiment</i>.</p>
- *          <p>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.</p>
- *          <p>You can add tags to a trial and then use the <a>Search</a> API to search for
- *       the tags.</p>
- *          <p>To get a list of all your trials, call the <a>ListTrials</a> API. To view a
- *       trial's properties, call the <a>DescribeTrial</a> API. To create a trial component,
- *       call the <a>CreateTrialComponent</a> API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateTrialCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateTrialCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateTrialCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrialCommandInput} for command's `input` shape.
- * @see {@link CreateTrialCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTrialCommand extends $Command<CreateTrialCommandInput, CreateTrialCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateTrialCommandInput;
     constructor(input: CreateTrialCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrialCommandInput, CreateTrialCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateTrialComponentCommand.d.ts

@@ -6,38 +6,11 @@ export interface CreateTrialComponentCommandInput extends CreateTrialComponentRe
 }
 export interface CreateTrialComponentCommandOutput extends CreateTrialComponentResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a <i>trial component</i>, which is a stage of a machine learning
- *         <i>trial</i>. A trial is composed of one or more trial components. A trial
- *       component can be used in multiple trials.</p>
- *          <p>Trial components include pre-processing jobs, training jobs, and batch transform
- *       jobs.</p>
- *          <p>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.</p>
- *          <p>You can add tags to a trial component and then use the <a>Search</a> API to
- *       search for the tags.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateTrialComponentCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateTrialComponentCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateTrialComponentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTrialComponentCommandInput} for command's `input` shape.
- * @see {@link CreateTrialComponentCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTrialComponentCommand extends $Command<CreateTrialComponentCommandInput, CreateTrialComponentCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateTrialComponentCommandInput;
     constructor(input: CreateTrialComponentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrialComponentCommandInput, CreateTrialComponentCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateUserProfileCommand.d.ts

@@ -6,35 +6,11 @@ export interface CreateUserProfileCommandInput extends CreateUserProfileRequest
 }
 export interface CreateUserProfileCommandOutput extends CreateUserProfileResponse, __MetadataBearer {
 }
-/**
- * <p>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 SSO, 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.
- *    </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateUserProfileCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateUserProfileCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateUserProfileCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateUserProfileCommandInput} for command's `input` shape.
- * @see {@link CreateUserProfileCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateUserProfileCommand extends $Command<CreateUserProfileCommandInput, CreateUserProfileCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateUserProfileCommandInput;
     constructor(input: CreateUserProfileCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateUserProfileCommandInput, CreateUserProfileCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateWorkforceCommand.d.ts

@@ -6,49 +6,11 @@ export interface CreateWorkforceCommandInput extends CreateWorkforceRequest {
 }
 export interface CreateWorkforceCommandOutput extends CreateWorkforceResponse, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- *
- *         <p>If you want to create a new workforce in an Amazon Web Services Region where
- *       a workforce already exists, use the  API
- *       operation to delete the existing workforce and then use <code>CreateWorkforce</code>
- *       to create a new workforce.</p>
- *
- *          <p>To create a private workforce using Amazon Cognito, you must specify a Cognito user pool
- *     in <code>CognitoConfig</code>.
- *     You can also create an Amazon Cognito workforce using the Amazon SageMaker console.
- *     For more information, see
- *       <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private.html">
- *       Create a Private Workforce (Amazon Cognito)</a>.</p>
- *
- *          <p>To create a private workforce using your own OIDC Identity Provider (IdP), specify your IdP
- *       configuration in <code>OidcConfig</code>. Your OIDC IdP must support <i>groups</i>
- *       because groups are used by Ground Truth and Amazon A2I to create work teams.
- *       For more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private-oidc.html">
- *       Create a Private Workforce (OIDC IdP)</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateWorkforceCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateWorkforceCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateWorkforceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateWorkforceCommandInput} for command's `input` shape.
- * @see {@link CreateWorkforceCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateWorkforceCommand extends $Command<CreateWorkforceCommandInput, CreateWorkforceCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateWorkforceCommandInput;
     constructor(input: CreateWorkforceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWorkforceCommandInput, CreateWorkforceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateWorkteamCommand.d.ts

@@ -6,32 +6,11 @@ export interface CreateWorkteamCommandInput extends CreateWorkteamRequest {
 }
 export interface CreateWorkteamCommandOutput extends CreateWorkteamResponse, __MetadataBearer {
 }
-/**
- * <p>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.</p>
- *         <p>You cannot create more than 25 work teams in an account and region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateWorkteamCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateWorkteamCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateWorkteamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateWorkteamCommandInput} for command's `input` shape.
- * @see {@link CreateWorkteamCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateWorkteamCommand extends $Command<CreateWorkteamCommandInput, CreateWorkteamCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateWorkteamCommandInput;
     constructor(input: CreateWorkteamCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWorkteamCommandInput, CreateWorkteamCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteActionCommand.d.ts

@@ -6,29 +6,11 @@ export interface DeleteActionCommandInput extends DeleteActionRequest {
 }
 export interface DeleteActionCommandOutput extends DeleteActionResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, DeleteActionCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, DeleteActionCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new DeleteActionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteActionCommandInput} for command's `input` shape.
- * @see {@link DeleteActionCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteActionCommand extends $Command<DeleteActionCommandInput, DeleteActionCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: DeleteActionCommandInput;
     constructor(input: DeleteActionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteActionCommandInput, DeleteActionCommandOutput>;
     private serialize;
     private deserialize;