@aws-sdk/client-sagemaker 3.36.0 → 3.39.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,49 +6,11 @@ export interface ListTrainingJobsCommandInput extends ListTrainingJobsRequest {
 }
 export interface ListTrainingJobsCommandOutput extends ListTrainingJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists training jobs.</p>
- *         <note>
- *             <p>When <code>StatusEquals</code> and <code>MaxResults</code> are set at the same
- *                 time, the <code>MaxResults</code> number of training jobs are first retrieved
- *                 ignoring the <code>StatusEquals</code> parameter and then they are filtered by the
- *                     <code>StatusEquals</code> parameter, which is returned as a response.</p>
- *             <p>For example, if <code>ListTrainingJobs</code> is invoked with the following
- *                 parameters:</p>
- *             <p>
- *                <code>{ ... MaxResults: 100, StatusEquals: InProgress ... }</code>
- *             </p>
- *             <p>First, 100 trainings jobs with any status, including those other than
- *                     <code>InProgress</code>, are selected (sorted according to the creation time,
- *                 from the most current to the oldest). Next, those with a status of
- *                     <code>InProgress</code> are returned.</p>
- *             <p>You can quickly test the API using the following Amazon Web Services CLI code.</p>
- *             <p>
- *                <code>aws sagemaker list-training-jobs --max-results 100 --status-equals
- *                     InProgress</code>
- *             </p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, ListTrainingJobsCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, ListTrainingJobsCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new ListTrainingJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTrainingJobsCommandInput} for command's `input` shape.
- * @see {@link ListTrainingJobsCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTrainingJobsCommand extends $Command<ListTrainingJobsCommandInput, ListTrainingJobsCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: ListTrainingJobsCommandInput;
     constructor(input: ListTrainingJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTrainingJobsCommandInput, ListTrainingJobsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListTrainingJobsForHyperParameterTuningJobCommandInput extends
 }
 export interface ListTrainingJobsForHyperParameterTuningJobCommandOutput extends ListTrainingJobsForHyperParameterTuningJobResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of <a>TrainingJobSummary</a> objects that describe the training
- *             jobs that a hyperparameter tuning job launched.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, ListTrainingJobsForHyperParameterTuningJobCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, ListTrainingJobsForHyperParameterTuningJobCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new ListTrainingJobsForHyperParameterTuningJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTrainingJobsForHyperParameterTuningJobCommandInput} for command's `input` shape.
- * @see {@link ListTrainingJobsForHyperParameterTuningJobCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTrainingJobsForHyperParameterTuningJobCommand extends $Command<ListTrainingJobsForHyperParameterTuningJobCommandInput, ListTrainingJobsForHyperParameterTuningJobCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: ListTrainingJobsForHyperParameterTuningJobCommandInput;
     constructor(input: ListTrainingJobsForHyperParameterTuningJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTrainingJobsForHyperParameterTuningJobCommandInput, ListTrainingJobsForHyperParameterTuningJobCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,31 +6,11 @@ export interface PutModelPackageGroupPolicyCommandInput extends PutModelPackageG
 }
 export interface PutModelPackageGroupPolicyCommandOutput extends PutModelPackageGroupPolicyOutput, __MetadataBearer {
 }
-/**
- * <p>Adds a resouce policy to control access to a model group. For information about
- *             resoure policies, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html">Identity-based
- *                 policies and resource-based policies</a> in the <i>Amazon Web Services Identity and Access Management User Guide.</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SageMakerClient, PutModelPackageGroupPolicyCommand } from "@aws-sdk/client-sagemaker"; // ES Modules import
- * // const { SageMakerClient, PutModelPackageGroupPolicyCommand } = require("@aws-sdk/client-sagemaker"); // CommonJS import
- * const client = new SageMakerClient(config);
- * const command = new PutModelPackageGroupPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutModelPackageGroupPolicyCommandInput} for command's `input` shape.
- * @see {@link PutModelPackageGroupPolicyCommandOutput} for command's `response` shape.
- * @see {@link SageMakerClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutModelPackageGroupPolicyCommand extends $Command<PutModelPackageGroupPolicyCommandInput, PutModelPackageGroupPolicyCommandOutput, SageMakerClientResolvedConfig> {
     readonly input: PutModelPackageGroupPolicyCommandInput;
     constructor(input: PutModelPackageGroupPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SageMakerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutModelPackageGroupPolicyCommandInput, PutModelPackageGroupPolicyCommandOutput>;
     private serialize;
     private deserialize;