@aws-sdk/client-ecs 3.36.0 → 3.39.0

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

@@ -6,30 +6,11 @@ export interface DeleteTaskSetCommandInput extends DeleteTaskSetRequest {
 }
 export interface DeleteTaskSetCommandOutput extends DeleteTaskSetResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a specified task set within a service. This is used when a service uses the
- * 				<code>EXTERNAL</code> deployment controller type. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DeleteTaskSetCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DeleteTaskSetCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DeleteTaskSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTaskSetCommandInput} for command's `input` shape.
- * @see {@link DeleteTaskSetCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteTaskSetCommand extends $Command<DeleteTaskSetCommandInput, DeleteTaskSetCommandOutput, ECSClientResolvedConfig> {
     readonly input: DeleteTaskSetCommandInput;
     constructor(input: DeleteTaskSetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTaskSetCommandInput, DeleteTaskSetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface DeregisterContainerInstanceCommandInput extends DeregisterConta
 }
 export interface DeregisterContainerInstanceCommandOutput extends DeregisterContainerInstanceResponse, __MetadataBearer {
 }
-/**
- * <p>Deregisters an Amazon ECS container instance from the specified cluster. This instance is
- * 			no longer available to run tasks.</p>
- * 		       <p>If you intend to use the container instance for some other purpose after
- * 			deregistration, you should stop all of the tasks running on the container instance
- * 			before deregistration. That prevents any orphaned tasks from consuming resources.</p>
- * 		       <p>Deregistering a container instance removes the instance from a cluster, but it does
- * 			not terminate the EC2 instance. If you are finished using the instance, be sure to
- * 			terminate it in the Amazon EC2 console to stop billing.</p>
- * 		       <note>
- * 			         <p>If you terminate a running container instance, Amazon ECS automatically deregisters the
- * 				instance from your cluster (stopped container instances or instances with
- * 				disconnected agents are not automatically deregistered when terminated).</p>
- * 		       </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DeregisterContainerInstanceCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DeregisterContainerInstanceCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DeregisterContainerInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterContainerInstanceCommandInput} for command's `input` shape.
- * @see {@link DeregisterContainerInstanceCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterContainerInstanceCommand extends $Command<DeregisterContainerInstanceCommandInput, DeregisterContainerInstanceCommandOutput, ECSClientResolvedConfig> {
     readonly input: DeregisterContainerInstanceCommandInput;
     constructor(input: DeregisterContainerInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterContainerInstanceCommandInput, DeregisterContainerInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,44 +6,11 @@ export interface DeregisterTaskDefinitionCommandInput extends DeregisterTaskDefi
 }
 export interface DeregisterTaskDefinitionCommandOutput extends DeregisterTaskDefinitionResponse, __MetadataBearer {
 }
-/**
- * <p>Deregisters the specified task definition by family and revision. Upon deregistration,
- * 			the task definition is marked as <code>INACTIVE</code>. Existing tasks and services that
- * 			reference an <code>INACTIVE</code> task definition continue to run without disruption.
- * 			Existing services that reference an <code>INACTIVE</code> task definition can still
- * 			scale up or down by modifying the service's desired count.</p>
- * 		       <p>You cannot use an <code>INACTIVE</code> task definition to run new tasks or create new
- * 			services, and you cannot update an existing service to reference an
- * 				<code>INACTIVE</code> task definition. However, there may be up to a 10-minute
- * 			window following deregistration where these restrictions have not yet taken
- * 			effect.</p>
- * 		       <note>
- * 			         <p>At this time, <code>INACTIVE</code> task definitions remain discoverable in your
- * 				account indefinitely. However, this behavior is subject to change in the future, so
- * 				you should not rely on <code>INACTIVE</code> task definitions persisting beyond the
- * 				lifecycle of any associated tasks and services.</p>
- * 		       </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DeregisterTaskDefinitionCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DeregisterTaskDefinitionCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DeregisterTaskDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeregisterTaskDefinitionCommandInput} for command's `input` shape.
- * @see {@link DeregisterTaskDefinitionCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeregisterTaskDefinitionCommand extends $Command<DeregisterTaskDefinitionCommandInput, DeregisterTaskDefinitionCommandOutput, ECSClientResolvedConfig> {
     readonly input: DeregisterTaskDefinitionCommandInput;
     constructor(input: DeregisterTaskDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterTaskDefinitionCommandInput, DeregisterTaskDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeCapacityProvidersCommandInput extends DescribeCapacityP
 }
 export interface DescribeCapacityProvidersCommandOutput extends DescribeCapacityProvidersResponse, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your capacity providers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DescribeCapacityProvidersCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DescribeCapacityProvidersCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DescribeCapacityProvidersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCapacityProvidersCommandInput} for command's `input` shape.
- * @see {@link DescribeCapacityProvidersCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCapacityProvidersCommand extends $Command<DescribeCapacityProvidersCommandInput, DescribeCapacityProvidersCommandOutput, ECSClientResolvedConfig> {
     readonly input: DescribeCapacityProvidersCommandInput;
     constructor(input: DescribeCapacityProvidersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCapacityProvidersCommandInput, DescribeCapacityProvidersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeClustersCommandInput extends DescribeClustersRequest {
 }
 export interface DescribeClustersCommandOutput extends DescribeClustersResponse, __MetadataBearer {
 }
-/**
- * <p>Describes one or more of your clusters.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DescribeClustersCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DescribeClustersCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DescribeClustersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeClustersCommandInput} for command's `input` shape.
- * @see {@link DescribeClustersCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeClustersCommand extends $Command<DescribeClustersCommandInput, DescribeClustersCommandOutput, ECSClientResolvedConfig> {
     readonly input: DescribeClustersCommandInput;
     constructor(input: DescribeClustersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeClustersCommandInput, DescribeClustersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeContainerInstancesCommandInput extends DescribeContaine
 }
 export interface DescribeContainerInstancesCommandOutput extends DescribeContainerInstancesResponse, __MetadataBearer {
 }
-/**
- * <p>Describes one or more container instances. Returns metadata about each container
- * 			instance requested.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DescribeContainerInstancesCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DescribeContainerInstancesCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DescribeContainerInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeContainerInstancesCommandInput} for command's `input` shape.
- * @see {@link DescribeContainerInstancesCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeContainerInstancesCommand extends $Command<DescribeContainerInstancesCommandInput, DescribeContainerInstancesCommandOutput, ECSClientResolvedConfig> {
     readonly input: DescribeContainerInstancesCommandInput;
     constructor(input: DescribeContainerInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeContainerInstancesCommandInput, DescribeContainerInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeServicesCommandInput extends DescribeServicesRequest {
 }
 export interface DescribeServicesCommandOutput extends DescribeServicesResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the specified services running in your cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DescribeServicesCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DescribeServicesCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DescribeServicesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeServicesCommandInput} for command's `input` shape.
- * @see {@link DescribeServicesCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeServicesCommand extends $Command<DescribeServicesCommandInput, DescribeServicesCommandOutput, ECSClientResolvedConfig> {
     readonly input: DescribeServicesCommandInput;
     constructor(input: DescribeServicesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeServicesCommandInput, DescribeServicesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DescribeTaskDefinitionCommandInput extends DescribeTaskDefiniti
 }
 export interface DescribeTaskDefinitionCommandOutput extends DescribeTaskDefinitionResponse, __MetadataBearer {
 }
-/**
- * <p>Describes a task definition. You can specify a <code>family</code> and
- * 				<code>revision</code> to find information about a specific task definition, or you
- * 			can simply specify the family to find the latest <code>ACTIVE</code> revision in that
- * 			family.</p>
- * 		       <note>
- * 			         <p>You can only describe <code>INACTIVE</code> task definitions while an active task
- * 				or service references them.</p>
- * 		       </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DescribeTaskDefinitionCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DescribeTaskDefinitionCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DescribeTaskDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTaskDefinitionCommandInput} for command's `input` shape.
- * @see {@link DescribeTaskDefinitionCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTaskDefinitionCommand extends $Command<DescribeTaskDefinitionCommandInput, DescribeTaskDefinitionCommandOutput, ECSClientResolvedConfig> {
     readonly input: DescribeTaskDefinitionCommandInput;
     constructor(input: DescribeTaskDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTaskDefinitionCommandInput, DescribeTaskDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeTaskSetsCommandInput extends DescribeTaskSetsRequest {
 }
 export interface DescribeTaskSetsCommandOutput extends DescribeTaskSetsResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the task sets in the specified cluster and service. This is used when a
- * 			service uses the <code>EXTERNAL</code> deployment controller type. For more information,
- * 			see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon ECS Deployment
- * 				Types</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DescribeTaskSetsCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DescribeTaskSetsCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DescribeTaskSetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTaskSetsCommandInput} for command's `input` shape.
- * @see {@link DescribeTaskSetsCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTaskSetsCommand extends $Command<DescribeTaskSetsCommandInput, DescribeTaskSetsCommandOutput, ECSClientResolvedConfig> {
     readonly input: DescribeTaskSetsCommandInput;
     constructor(input: DescribeTaskSetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTaskSetsCommandInput, DescribeTaskSetsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeTasksCommandInput extends DescribeTasksRequest {
 }
 export interface DescribeTasksCommandOutput extends DescribeTasksResponse, __MetadataBearer {
 }
-/**
- * <p>Describes a specified task or tasks.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DescribeTasksCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DescribeTasksCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DescribeTasksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTasksCommandInput} for command's `input` shape.
- * @see {@link DescribeTasksCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTasksCommand extends $Command<DescribeTasksCommandInput, DescribeTasksCommandOutput, ECSClientResolvedConfig> {
     readonly input: DescribeTasksCommandInput;
     constructor(input: DescribeTasksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTasksCommandInput, DescribeTasksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DiscoverPollEndpointCommandInput extends DiscoverPollEndpointRe
 }
 export interface DiscoverPollEndpointCommandOutput extends DiscoverPollEndpointResponse, __MetadataBearer {
 }
-/**
- * <note>
- *             <p>This action is only used by the Amazon ECS agent, and it is not intended for use outside of the agent.</p>
- *          </note>
- *          <p>Returns an endpoint for
- * 			the Amazon ECS agent to poll for updates.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DiscoverPollEndpointCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DiscoverPollEndpointCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DiscoverPollEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DiscoverPollEndpointCommandInput} for command's `input` shape.
- * @see {@link DiscoverPollEndpointCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DiscoverPollEndpointCommand extends $Command<DiscoverPollEndpointCommandInput, DiscoverPollEndpointCommandOutput, ECSClientResolvedConfig> {
     readonly input: DiscoverPollEndpointCommandInput;
     constructor(input: DiscoverPollEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DiscoverPollEndpointCommandInput, DiscoverPollEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ExecuteCommandCommandInput extends ExecuteCommandRequest {
 }
 export interface ExecuteCommandCommandOutput extends ExecuteCommandResponse, __MetadataBearer {
 }
-/**
- * <p>Runs a command remotely on a container within a task.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, ExecuteCommandCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, ExecuteCommandCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new ExecuteCommandCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ExecuteCommandCommandInput} for command's `input` shape.
- * @see {@link ExecuteCommandCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ExecuteCommandCommand extends $Command<ExecuteCommandCommandInput, ExecuteCommandCommandOutput, ECSClientResolvedConfig> {
     readonly input: ExecuteCommandCommandInput;
     constructor(input: ExecuteCommandCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteCommandCommandInput, ExecuteCommandCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListAccountSettingsCommandInput extends ListAccountSettingsRequ
 }
 export interface ListAccountSettingsCommandOutput extends ListAccountSettingsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the account settings for a specified principal.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, ListAccountSettingsCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, ListAccountSettingsCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new ListAccountSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListAccountSettingsCommandInput} for command's `input` shape.
- * @see {@link ListAccountSettingsCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListAccountSettingsCommand extends $Command<ListAccountSettingsCommandInput, ListAccountSettingsCommandOutput, ECSClientResolvedConfig> {
     readonly input: ListAccountSettingsCommandInput;
     constructor(input: ListAccountSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAccountSettingsCommandInput, ListAccountSettingsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface ListAttributesCommandInput extends ListAttributesRequest {
 }
 export interface ListAttributesCommandOutput extends ListAttributesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the attributes for Amazon ECS resources within a specified target type and cluster.
- * 			When you specify a target type and cluster, <code>ListAttributes</code> returns a list
- * 			of attribute objects, one for each attribute on each resource. You can filter the list
- * 			of results to a single attribute name to only return results that have that name. You
- * 			can also filter the results by attribute name and value, for example, to see which
- * 			container instances in a cluster are running a Linux AMI
- * 			(<code>ecs.os-type=linux</code>). </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, ListAttributesCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, ListAttributesCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new ListAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListAttributesCommandInput} for command's `input` shape.
- * @see {@link ListAttributesCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListAttributesCommand extends $Command<ListAttributesCommandInput, ListAttributesCommandOutput, ECSClientResolvedConfig> {
     readonly input: ListAttributesCommandInput;
     constructor(input: ListAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAttributesCommandInput, ListAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface ListContainerInstancesCommandInput extends ListContainerInstanc
 }
 export interface ListContainerInstancesCommandOutput extends ListContainerInstancesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of container instances in a specified cluster. You can filter the
- * 			results of a <code>ListContainerInstances</code> operation with cluster query language
- * 			statements inside the <code>filter</code> parameter. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html">Cluster Query Language</a> in the
- * 				<i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, ListContainerInstancesCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, ListContainerInstancesCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new ListContainerInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListContainerInstancesCommandInput} for command's `input` shape.
- * @see {@link ListContainerInstancesCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListContainerInstancesCommand extends $Command<ListContainerInstancesCommandInput, ListContainerInstancesCommandOutput, ECSClientResolvedConfig> {
     readonly input: ListContainerInstancesCommandInput;
     constructor(input: ListContainerInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListContainerInstancesCommandInput, ListContainerInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListServicesCommandInput extends ListServicesRequest {
 }
 export interface ListServicesCommandOutput extends ListServicesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of services. You can filter the results by cluster, launch type, and
- * 			scheduling strategy.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, ListServicesCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, ListServicesCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new ListServicesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListServicesCommandInput} for command's `input` shape.
- * @see {@link ListServicesCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListServicesCommand extends $Command<ListServicesCommandInput, ListServicesCommandOutput, ECSClientResolvedConfig> {
     readonly input: ListServicesCommandInput;
     constructor(input: ListServicesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListServicesCommandInput, ListServicesCommandOutput>;
     private serialize;
     private deserialize;

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

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