@aws-sdk/client-sagemaker 3.36.0 → 3.39.0

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

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

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

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

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

@@ -6,31 +6,11 @@ export interface CreateImageCommandInput extends CreateImageRequest {
 }
 export interface CreateImageCommandOutput extends CreateImageResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a custom SageMaker image. A SageMaker image is a set of image versions. Each image
- *         version represents a container image stored in Amazon Container Registry (ECR). For more information, see
- *         <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/studio-byoi.html">Bring your own SageMaker image</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateImageCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateImageCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateImageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateImageCommandInput} for command's `input` shape.
- * @see {@link CreateImageCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateImageCommand extends $Command<CreateImageCommandInput, CreateImageCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateImageCommandInput;
     constructor(input: CreateImageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateImageCommandInput, CreateImageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateImageVersionCommandInput extends CreateImageVersionReques
 }
 export interface CreateImageVersionCommandOutput extends CreateImageVersionResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a version of the SageMaker image specified by <code>ImageName</code>. The version
- *         represents the Amazon Container Registry (ECR) container image specified by <code>BaseImage</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateImageVersionCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateImageVersionCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateImageVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateImageVersionCommandInput} for command's `input` shape.
- * @see {@link CreateImageVersionCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateImageVersionCommand extends $Command<CreateImageVersionCommandInput, CreateImageVersionCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateImageVersionCommandInput;
     constructor(input: CreateImageVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateImageVersionCommandInput, CreateImageVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,71 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
-import { CreateLabelingJobRequest, CreateLabelingJobResponse } from "../models/models_0";
+import { CreateLabelingJobRequest, CreateLabelingJobResponse } from "../models/models_1";
 import { SageMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SageMakerClient";
 export interface CreateLabelingJobCommandInput extends CreateLabelingJobRequest {
 }
 export interface CreateLabelingJobCommandOutput extends CreateLabelingJobResponse, __MetadataBearer {
 }
-/**
- * <p>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. </p>
- *         <p>You can select your workforce from one of three providers:</p>
- *         <ul>
- *             <li>
- *                 <p>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.</p>
- *             </li>
- *             <li>
- *                 <p>One or more vendors that you select from the Amazon Web Services Marketplace. Vendors provide
- *                     expertise in specific areas. </p>
- *             </li>
- *             <li>
- *                 <p>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.</p>
- *             </li>
- *          </ul>
- *         <p>You can also use <i>automated data labeling</i> to reduce the number of
- *             data objects that need to be labeled by a human. Automated data labeling uses
- *                 <i>active learning</i> 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 <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-automated-labeling.html">Using
- *                 Automated Data Labeling</a>.</p>
- *         <p>The data objects to be labeled are contained in an Amazon S3 bucket. You create a
- *                 <i>manifest file</i> that describes the location of each object. For
- *             more information, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data.html">Using Input and Output Data</a>.</p>
- *         <p>The output can be used as the manifest file for another labeling job or as training
- *             data for your machine learning models.</p>
- *         <p>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 <code>ManifestS3Uri</code> 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 (<code>InProgress</code>) streaming labeling job in real
- *             time. To learn how to create a static labeling job, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-create-labeling-job-api.html">Create a Labeling Job
- *                 (API) </a> in the Amazon SageMaker Developer Guide. To learn how to create a streaming
- *             labeling job, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/sms-streaming-create-job.html">Create a Streaming Labeling
- *                 Job</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateLabelingJobCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateLabelingJobCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateLabelingJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLabelingJobCommandInput} for command's `input` shape.
- * @see {@link CreateLabelingJobCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateLabelingJobCommand extends $Command<CreateLabelingJobCommandInput, CreateLabelingJobCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateLabelingJobCommandInput;
     constructor(input: CreateLabelingJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLabelingJobCommandInput, CreateLabelingJobCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -1,58 +1,16 @@
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
-import { CreateModelInput, CreateModelOutput } from "../models/models_0";
+import { CreateModelInput, CreateModelOutput } from "../models/models_1";
 import { SageMakerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SageMakerClient";
 export interface CreateModelCommandInput extends CreateModelInput {
 }
 export interface CreateModelCommandOutput extends CreateModelOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a model in Amazon 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.</p>
- *         <p>Use this API to create a model if you want to use Amazon SageMaker hosting services or run a batch
- *             transform job.</p>
- *         <p>To host your model, you create an endpoint configuration with the
- *                 <code>CreateEndpointConfig</code> API, and then create an endpoint with the
- *                 <code>CreateEndpoint</code> API. Amazon SageMaker then deploys all of the containers that you
- *             defined for the model in the hosting environment. </p>
- *         <p>For an example that calls this method when deploying a model to Amazon SageMaker hosting services,
- *             see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html#ex1-deploy-model-boto">Deploy the
- *                 Model to Amazon SageMaker Hosting Services (Amazon Web Services SDK for Python (Boto
- *             3)).</a>
- *          </p>
- *         <p>To run a batch transform using your model, you start a job with the
- *                 <code>CreateTransformJob</code> API. Amazon SageMaker uses your model and your dataset to get
- *             inferences which are then saved to a specified S3 location.</p>
- *         <p>In the <code>CreateModel</code> request, you must define a container with the
- *                 <code>PrimaryContainer</code> parameter.</p>
- *         <p>In the request, you also provide an IAM role that Amazon 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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateModelCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateModelCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateModelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateModelCommandInput} for command's `input` shape.
- * @see {@link CreateModelCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateModelCommand extends $Command<CreateModelCommandInput, CreateModelCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateModelCommandInput;
     constructor(input: CreateModelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateModelCommandInput, CreateModelCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,48 +6,11 @@ export interface CreateModelPackageCommandInput extends CreateModelPackageInput
 }
 export interface CreateModelPackageCommandOutput extends CreateModelPackageOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a model package that you can use to create Amazon 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 Amazon SageMaker.</p>
- *         <p>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
- *                 <code>InferenceSpecification</code>. To create a model from an algorithm resource
- *             that you created or subscribed to in Amazon Web Services Marketplace, provide a value for
- *                 <code>SourceAlgorithmSpecification</code>.</p>
- *         <note>
- *             <p>There are two types of model packages:</p>
- *             <ul>
- *                <li>
- *                     <p>Versioned - a model that is part of a model group in the model
- *                         registry.</p>
- *                 </li>
- *                <li>
- *                     <p>Unversioned - a model package that is not part of a model group.</p>
- *                 </li>
- *             </ul>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateModelPackageCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateModelPackageCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateModelPackageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateModelPackageCommandInput} for command's `input` shape.
- * @see {@link CreateModelPackageCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateModelPackageCommand extends $Command<CreateModelPackageCommandInput, CreateModelPackageCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateModelPackageCommandInput;
     constructor(input: CreateModelPackageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateModelPackageCommandInput, CreateModelPackageCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface CreateModelQualityJobDefinitionCommandInput extends CreateModel
 }
 export interface CreateModelQualityJobDefinitionCommandOutput extends CreateModelQualityJobDefinitionResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a definition for a job that monitors model quality and drift. For information
- *          about model monitor, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html">Amazon SageMaker Model Monitor</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateModelQualityJobDefinitionCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateModelQualityJobDefinitionCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateModelQualityJobDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateModelQualityJobDefinitionCommandInput} for command's `input` shape.
- * @see {@link CreateModelQualityJobDefinitionCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateModelQualityJobDefinitionCommand extends $Command<CreateModelQualityJobDefinitionCommandInput, CreateModelQualityJobDefinitionCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateModelQualityJobDefinitionCommandInput;
     constructor(input: CreateModelQualityJobDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateModelQualityJobDefinitionCommandInput, CreateModelQualityJobDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateMonitoringScheduleCommandInput extends CreateMonitoringSc
 }
 export interface CreateMonitoringScheduleCommandOutput extends CreateMonitoringScheduleResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a schedule that regularly starts Amazon SageMaker Processing Jobs to monitor the data
- *          captured for an Amazon SageMaker Endoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateMonitoringScheduleCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateMonitoringScheduleCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateMonitoringScheduleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateMonitoringScheduleCommandInput} for command's `input` shape.
- * @see {@link CreateMonitoringScheduleCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateMonitoringScheduleCommand extends $Command<CreateMonitoringScheduleCommandInput, CreateMonitoringScheduleCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateMonitoringScheduleCommandInput;
     constructor(input: CreateMonitoringScheduleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMonitoringScheduleCommandInput, CreateMonitoringScheduleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,65 +6,11 @@ export interface CreateNotebookInstanceCommandInput extends CreateNotebookInstan
 }
 export interface CreateNotebookInstanceCommandOutput extends CreateNotebookInstanceOutput, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon SageMaker notebook instance. A notebook instance is a machine learning (ML)
- *             compute instance running on a Jupyter notebook. </p>
- *         <p>In a <code>CreateNotebookInstance</code> request, specify the type of ML compute
- *             instance that you want to run. Amazon 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. </p>
- *         <p>Amazon SageMaker also provides a set of example notebooks. Each notebook demonstrates how to
- *             use Amazon SageMaker with a specific algorithm or with a machine learning framework. </p>
- *         <p>After receiving the request, Amazon SageMaker does the following:</p>
- *         <ol>
- *             <li>
- *                 <p>Creates a network interface in the Amazon SageMaker VPC.</p>
- *             </li>
- *             <li>
- *                 <p>(Option) If you specified <code>SubnetId</code>, Amazon 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, Amazon SageMaker attaches the security
- *                     group that you specified in the request to the network interface that it creates
- *                     in your VPC.</p>
- *
- *             </li>
- *             <li>
- *                 <p>Launches an EC2 instance of the type specified in the request in the Amazon SageMaker
- *                     VPC. If you specified <code>SubnetId</code> of your VPC, Amazon 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.</p>
- *             </li>
- *          </ol>
- *
- *         <p>After creating the notebook instance, Amazon SageMaker returns its Amazon Resource Name (ARN).
- *             You can't change the name of a notebook instance after you create it.</p>
- *         <p>After Amazon 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 Amazon SageMaker endpoints, and
- *             validate hosted models. </p>
- *         <p>For more information, 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, CreateNotebookInstanceCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateNotebookInstanceCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateNotebookInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNotebookInstanceCommandInput} for command's `input` shape.
- * @see {@link CreateNotebookInstanceCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNotebookInstanceCommand extends $Command<CreateNotebookInstanceCommandInput, CreateNotebookInstanceCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateNotebookInstanceCommandInput;
     constructor(input: CreateNotebookInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNotebookInstanceCommandInput, CreateNotebookInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface CreateNotebookInstanceLifecycleConfigCommandInput extends Creat
 }
 export interface CreateNotebookInstanceLifecycleConfigCommandOutput extends CreateNotebookInstanceLifecycleConfigOutput, __MetadataBearer {
 }
-/**
- * <p>Creates a lifecycle configuration that you can associate with a notebook instance. A
- *                 <i>lifecycle configuration</i> is a collection of shell scripts that
- *             run when you create or start a notebook instance.</p>
- *         <p>Each lifecycle configuration script has a limit of 16384 characters.</p>
- *         <p>The value of the <code>$PATH</code> environment variable that is available to both
- *             scripts is <code>/sbin:bin:/usr/sbin:/usr/bin</code>.</p>
- *         <p>View CloudWatch Logs for notebook instance lifecycle configurations in log group
- *                 <code>/aws/sagemaker/NotebookInstances</code> in log stream
- *                 <code>[notebook-instance-name]/[LifecycleConfigHook]</code>.</p>
- *         <p>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.</p>
- *         <p>For information about notebook instance lifestyle configurations, see <a href="https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html">Step
- *                 2.1: (Optional) Customize a Notebook Instance</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, CreateNotebookInstanceLifecycleConfigCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, CreateNotebookInstanceLifecycleConfigCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new CreateNotebookInstanceLifecycleConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateNotebookInstanceLifecycleConfigCommandInput} for command's `input` shape.
- * @see {@link CreateNotebookInstanceLifecycleConfigCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateNotebookInstanceLifecycleConfigCommand extends $Command<CreateNotebookInstanceLifecycleConfigCommandInput, CreateNotebookInstanceLifecycleConfigCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: CreateNotebookInstanceLifecycleConfigCommandInput;
     constructor(input: CreateNotebookInstanceLifecycleConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateNotebookInstanceLifecycleConfigCommandInput, CreateNotebookInstanceLifecycleConfigCommandOutput>;
     private serialize;
     private deserialize;