@aws-sdk/client-ecs 3.36.0 → 3.39.0

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

@@ -6,35 +6,11 @@ export interface ListTaskDefinitionFamiliesCommandInput extends ListTaskDefiniti
 }
 export interface ListTaskDefinitionFamiliesCommandOutput extends ListTaskDefinitionFamiliesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of task definition families that are registered to your account (which
- * 			may include task definition families that no longer have any <code>ACTIVE</code> task
- * 			definition revisions).</p>
- * 		       <p>You can filter out task definition families that do not contain any
- * 				<code>ACTIVE</code> task definition revisions by setting the <code>status</code>
- * 			parameter to <code>ACTIVE</code>. You can also filter the results with the
- * 				<code>familyPrefix</code> parameter.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, ListTaskDefinitionFamiliesCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, ListTaskDefinitionFamiliesCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new ListTaskDefinitionFamiliesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTaskDefinitionFamiliesCommandInput} for command's `input` shape.
- * @see {@link ListTaskDefinitionFamiliesCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTaskDefinitionFamiliesCommand extends $Command<ListTaskDefinitionFamiliesCommandInput, ListTaskDefinitionFamiliesCommandOutput, ECSClientResolvedConfig> {
     readonly input: ListTaskDefinitionFamiliesCommandInput;
     constructor(input: ListTaskDefinitionFamiliesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTaskDefinitionFamiliesCommandInput, ListTaskDefinitionFamiliesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ListTaskDefinitionsCommandInput extends ListTaskDefinitionsRequ
 }
 export interface ListTaskDefinitionsCommandOutput extends ListTaskDefinitionsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of task definitions that are registered to your account. You can filter
- * 			the results by family name with the <code>familyPrefix</code> parameter or by status
- * 			with the <code>status</code> parameter.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, ListTaskDefinitionsCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, ListTaskDefinitionsCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new ListTaskDefinitionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTaskDefinitionsCommandInput} for command's `input` shape.
- * @see {@link ListTaskDefinitionsCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTaskDefinitionsCommand extends $Command<ListTaskDefinitionsCommandInput, ListTaskDefinitionsCommandOutput, ECSClientResolvedConfig> {
     readonly input: ListTaskDefinitionsCommandInput;
     constructor(input: ListTaskDefinitionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTaskDefinitionsCommandInput, ListTaskDefinitionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ListTasksCommandInput extends ListTasksRequest {
 }
 export interface ListTasksCommandOutput extends ListTasksResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of tasks. You can filter the results by cluster, task definition
- * 			family, container instance, launch type, what IAM principal started the task, or by the
- * 			desired status of the task.</p>
- * 		       <p>Recently stopped tasks might appear in the returned results. Currently, stopped tasks
- * 			appear in the returned results for at least one hour.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, ListTasksCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, ListTasksCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new ListTasksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTasksCommandInput} for command's `input` shape.
- * @see {@link ListTasksCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTasksCommand extends $Command<ListTasksCommandInput, ListTasksCommandOutput, ECSClientResolvedConfig> {
     readonly input: ListTasksCommandInput;
     constructor(input: ListTasksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTasksCommandInput, ListTasksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,52 +6,11 @@ export interface PutAccountSettingCommandInput extends PutAccountSettingRequest
 }
 export interface PutAccountSettingCommandOutput extends PutAccountSettingResponse, __MetadataBearer {
 }
-/**
- * <p>Modifies an account setting. Account settings are set on a per-Region basis.</p>
- * 		       <p>If you change the account setting for the root user, the default settings for all of
- * 			the IAM users and roles for which no individual account setting has been specified are
- * 			reset. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html">Account
- * 				Settings</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * 		       <p>When <code>serviceLongArnFormat</code>, <code>taskLongArnFormat</code>, or
- * 				<code>containerInstanceLongArnFormat</code> are specified, the Amazon Resource Name
- * 			(ARN) and resource ID format of the resource type for a specified IAM user, IAM role, or
- * 			the root user for an account is affected. The opt-in and opt-out account setting must be
- * 			set for each Amazon ECS resource separately. The ARN and resource ID format of a resource
- * 			will be defined by the opt-in status of the IAM user or role that created the resource.
- * 			You must enable this setting to use Amazon ECS features such as resource tagging.</p>
- * 		       <p>When <code>awsvpcTrunking</code> is specified, the elastic network interface (ENI)
- * 			limit for any new container instances that support the feature is changed. If
- * 				<code>awsvpcTrunking</code> is enabled, any new container instances that support the
- * 			feature are launched have the increased ENI limits available to them. For more
- * 			information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container-instance-eni.html">Elastic Network
- * 				Interface Trunking</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * 		       <p>When <code>containerInsights</code> is specified, the default setting indicating
- * 			whether CloudWatch Container Insights is enabled for your clusters is changed. If
- * 				<code>containerInsights</code> is enabled, any new clusters that are created will
- * 			have Container Insights enabled unless you disable it during cluster creation. For more
- * 			information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cloudwatch-container-insights.html">CloudWatch
- * 				Container Insights</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, PutAccountSettingCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, PutAccountSettingCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new PutAccountSettingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutAccountSettingCommandInput} for command's `input` shape.
- * @see {@link PutAccountSettingCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAccountSettingCommand extends $Command<PutAccountSettingCommandInput, PutAccountSettingCommandOutput, ECSClientResolvedConfig> {
     readonly input: PutAccountSettingCommandInput;
     constructor(input: PutAccountSettingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAccountSettingCommandInput, PutAccountSettingCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface PutAccountSettingDefaultCommandInput extends PutAccountSettingD
 }
 export interface PutAccountSettingDefaultCommandOutput extends PutAccountSettingDefaultResponse, __MetadataBearer {
 }
-/**
- * <p>Modifies an account setting for all IAM users on an account for whom no individual
- * 			account setting has been specified. Account settings are set on a per-Region
- * 			basis.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, PutAccountSettingDefaultCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, PutAccountSettingDefaultCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new PutAccountSettingDefaultCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutAccountSettingDefaultCommandInput} for command's `input` shape.
- * @see {@link PutAccountSettingDefaultCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAccountSettingDefaultCommand extends $Command<PutAccountSettingDefaultCommandInput, PutAccountSettingDefaultCommandOutput, ECSClientResolvedConfig> {
     readonly input: PutAccountSettingDefaultCommandInput;
     constructor(input: PutAccountSettingDefaultCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAccountSettingDefaultCommandInput, PutAccountSettingDefaultCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface PutAttributesCommandInput extends PutAttributesRequest {
 }
 export interface PutAttributesCommandOutput extends PutAttributesResponse, __MetadataBearer {
 }
-/**
- * <p>Create or update an attribute on an Amazon ECS resource. If the attribute does not exist,
- * 			it is created. If the attribute exists, its value is replaced with the specified value.
- * 			To delete an attribute, use <a>DeleteAttributes</a>. For more information,
- * 			see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes">Attributes</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, PutAttributesCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, PutAttributesCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new PutAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutAttributesCommandInput} for command's `input` shape.
- * @see {@link PutAttributesCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAttributesCommand extends $Command<PutAttributesCommandInput, PutAttributesCommandOutput, ECSClientResolvedConfig> {
     readonly input: PutAttributesCommandInput;
     constructor(input: PutAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAttributesCommandInput, PutAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface PutClusterCapacityProvidersCommandInput extends PutClusterCapac
 }
 export interface PutClusterCapacityProvidersCommandOutput extends PutClusterCapacityProvidersResponse, __MetadataBearer {
 }
-/**
- * <p>Modifies the available capacity providers and the default capacity provider strategy
- * 			for a cluster.</p>
- * 		       <p>You must specify both the available capacity providers and a default capacity provider
- * 			strategy for the cluster. If the specified cluster has existing capacity providers
- * 			associated with it, you must specify all existing capacity providers in addition to any
- * 			new ones you want to add. Any existing capacity providers associated with a cluster that
- * 			are omitted from a <a>PutClusterCapacityProviders</a> API call will be
- * 			disassociated with the cluster. You can only disassociate an existing capacity provider
- * 			from a cluster if it's not being used by any existing tasks.</p>
- * 		       <p>When creating a service or running a task on a cluster, if no capacity provider or
- * 			launch type is specified, then the cluster's default capacity provider strategy is used.
- * 			It is recommended to define a default capacity provider strategy for your cluster,
- * 			however you may specify an empty array (<code>[]</code>) to bypass defining a default
- * 			strategy.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, PutClusterCapacityProvidersCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, PutClusterCapacityProvidersCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new PutClusterCapacityProvidersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutClusterCapacityProvidersCommandInput} for command's `input` shape.
- * @see {@link PutClusterCapacityProvidersCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutClusterCapacityProvidersCommand extends $Command<PutClusterCapacityProvidersCommandInput, PutClusterCapacityProvidersCommandOutput, ECSClientResolvedConfig> {
     readonly input: PutClusterCapacityProvidersCommandInput;
     constructor(input: PutClusterCapacityProvidersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutClusterCapacityProvidersCommandInput, PutClusterCapacityProvidersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface RegisterContainerInstanceCommandInput extends RegisterContainer
 }
 export interface RegisterContainerInstanceCommandOutput extends RegisterContainerInstanceResponse, __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>Registers an EC2
- * 			instance into the specified cluster. This instance becomes available to place containers
- * 			on.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, RegisterContainerInstanceCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, RegisterContainerInstanceCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new RegisterContainerInstanceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RegisterContainerInstanceCommandInput} for command's `input` shape.
- * @see {@link RegisterContainerInstanceCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RegisterContainerInstanceCommand extends $Command<RegisterContainerInstanceCommandInput, RegisterContainerInstanceCommandOutput, ECSClientResolvedConfig> {
     readonly input: RegisterContainerInstanceCommandInput;
     constructor(input: RegisterContainerInstanceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterContainerInstanceCommandInput, RegisterContainerInstanceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,46 +6,11 @@ export interface RegisterTaskDefinitionCommandInput extends RegisterTaskDefiniti
 }
 export interface RegisterTaskDefinitionCommandOutput extends RegisterTaskDefinitionResponse, __MetadataBearer {
 }
-/**
- * <p>Registers a new task definition from the supplied <code>family</code> and
- * 				<code>containerDefinitions</code>. Optionally, you can add data volumes to your
- * 			containers with the <code>volumes</code> parameter. For more information about task
- * 			definition parameters and defaults, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html">Amazon ECS Task
- * 				Definitions</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * 		       <p>You can specify an IAM role for your task with the <code>taskRoleArn</code> parameter.
- * 			When you specify an IAM role for a task, its containers can then use the latest versions
- * 			of the CLI or SDKs to make API requests to the Amazon Web Services services that are specified in
- * 			the IAM policy associated with the role. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html">IAM
- * 				Roles for Tasks</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * 		       <p>You can specify a Docker networking mode for the containers in your task definition
- * 			with the <code>networkMode</code> parameter. The available network modes correspond to
- * 			those described in <a href="https://docs.docker.com/engine/reference/run/#/network-settings">Network
- * 				settings</a> in the Docker run reference. If you specify the <code>awsvpc</code>
- * 			network mode, the task is allocated an elastic network interface, and you must specify a
- * 				<a>NetworkConfiguration</a> when you create a service or run a task with
- * 			the task definition. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html">Task Networking</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, RegisterTaskDefinitionCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, RegisterTaskDefinitionCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new RegisterTaskDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RegisterTaskDefinitionCommandInput} for command's `input` shape.
- * @see {@link RegisterTaskDefinitionCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RegisterTaskDefinitionCommand extends $Command<RegisterTaskDefinitionCommandInput, RegisterTaskDefinitionCommandOutput, ECSClientResolvedConfig> {
     readonly input: RegisterTaskDefinitionCommandInput;
     constructor(input: RegisterTaskDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterTaskDefinitionCommandInput, RegisterTaskDefinitionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,57 +6,11 @@ export interface RunTaskCommandInput extends RunTaskRequest {
 }
 export interface RunTaskCommandOutput extends RunTaskResponse, __MetadataBearer {
 }
-/**
- * <p>Starts a new task using the specified task definition.</p>
- * 		       <p>You can allow Amazon ECS to place tasks for you, or you can customize how Amazon ECS places
- * 			tasks using placement constraints and placement strategies. For more information, see
- * 				<a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling Tasks</a> in the
- * 				<i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * 		       <p>Alternatively, you can use <a>StartTask</a> to use your own scheduler or
- * 			place tasks manually on specific container instances.</p>
- * 		       <p>The Amazon ECS API follows an eventual consistency model, due to the distributed nature of
- * 			the system supporting the API. This means that the result of an API command you run that
- * 			affects your Amazon ECS resources might not be immediately visible to all subsequent commands
- * 			you run. Keep this in mind when you carry out an API command that immediately follows a
- * 			previous API command.</p>
- * 		       <p>To manage eventual consistency, you can do the following:</p>
- * 		       <ul>
- *             <li>
- * 				           <p>Confirm the state of the resource before you run a command to modify it. Run
- * 					the DescribeTasks command using an exponential backoff algorithm to ensure that
- * 					you allow enough time for the previous command to propagate through the system.
- * 					To do this, run the DescribeTasks command repeatedly, starting with a couple of
- * 					seconds of wait time and increasing gradually up to five minutes of wait
- * 					time.</p>
- * 			         </li>
- *             <li>
- * 				           <p>Add wait time between subsequent commands, even if the DescribeTasks command
- * 					returns an accurate response. Apply an exponential backoff algorithm starting
- * 					with a couple of seconds of wait time, and increase gradually up to about five
- * 					minutes of wait time.</p>
- * 			         </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, RunTaskCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, RunTaskCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new RunTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RunTaskCommandInput} for command's `input` shape.
- * @see {@link RunTaskCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RunTaskCommand extends $Command<RunTaskCommandInput, RunTaskCommandOutput, ECSClientResolvedConfig> {
     readonly input: RunTaskCommandInput;
     constructor(input: RunTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RunTaskCommandInput, RunTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface StartTaskCommandInput extends StartTaskRequest {
 }
 export interface StartTaskCommandOutput extends StartTaskResponse, __MetadataBearer {
 }
-/**
- * <p>Starts a new task from the specified task definition on the specified container
- * 			instance or instances.</p>
- * 		       <p>Alternatively, you can use <a>RunTask</a> to place tasks for you. For more
- * 			information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/scheduling_tasks.html">Scheduling Tasks</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, StartTaskCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, StartTaskCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new StartTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartTaskCommandInput} for command's `input` shape.
- * @see {@link StartTaskCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartTaskCommand extends $Command<StartTaskCommandInput, StartTaskCommandOutput, ECSClientResolvedConfig> {
     readonly input: StartTaskCommandInput;
     constructor(input: StartTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartTaskCommandInput, StartTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface StopTaskCommandInput extends StopTaskRequest {
 }
 export interface StopTaskCommandOutput extends StopTaskResponse, __MetadataBearer {
 }
-/**
- * <p>Stops a running task. Any tags associated with the task will be deleted.</p>
- * 		       <p>When <a>StopTask</a> is called on a task, the equivalent of <code>docker
- * 				stop</code> is issued to the containers running in the task. This results in a
- * 				<code>SIGTERM</code> value and a default 30-second timeout, after which the
- * 				<code>SIGKILL</code> value is sent and the containers are forcibly stopped. If the
- * 			container handles the <code>SIGTERM</code> value gracefully and exits within 30 seconds
- * 			from receiving it, no <code>SIGKILL</code> value is sent.</p>
- * 		       <note>
- * 			         <p>The default 30-second timeout can be configured on the Amazon ECS container agent with
- * 				the <code>ECS_CONTAINER_STOP_TIMEOUT</code> variable. For more information, see
- * 					<a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html">Amazon ECS Container Agent Configuration</a> in the
- * 					<i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * 		       </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, StopTaskCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, StopTaskCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new StopTaskCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopTaskCommandInput} for command's `input` shape.
- * @see {@link StopTaskCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopTaskCommand extends $Command<StopTaskCommandInput, StopTaskCommandOutput, ECSClientResolvedConfig> {
     readonly input: StopTaskCommandInput;
     constructor(input: StopTaskCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopTaskCommandInput, StopTaskCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface SubmitAttachmentStateChangesCommandInput extends SubmitAttachme
 }
 export interface SubmitAttachmentStateChangesCommandOutput extends SubmitAttachmentStateChangesResponse, __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>Sent to
- * 			acknowledge that an attachment changed states.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, SubmitAttachmentStateChangesCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, SubmitAttachmentStateChangesCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new SubmitAttachmentStateChangesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SubmitAttachmentStateChangesCommandInput} for command's `input` shape.
- * @see {@link SubmitAttachmentStateChangesCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SubmitAttachmentStateChangesCommand extends $Command<SubmitAttachmentStateChangesCommandInput, SubmitAttachmentStateChangesCommandOutput, ECSClientResolvedConfig> {
     readonly input: SubmitAttachmentStateChangesCommandInput;
     constructor(input: SubmitAttachmentStateChangesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SubmitAttachmentStateChangesCommandInput, SubmitAttachmentStateChangesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface SubmitContainerStateChangeCommandInput extends SubmitContainerS
 }
 export interface SubmitContainerStateChangeCommandOutput extends SubmitContainerStateChangeResponse, __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>Sent to
- * 			acknowledge that a container changed states.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, SubmitContainerStateChangeCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, SubmitContainerStateChangeCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new SubmitContainerStateChangeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SubmitContainerStateChangeCommandInput} for command's `input` shape.
- * @see {@link SubmitContainerStateChangeCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SubmitContainerStateChangeCommand extends $Command<SubmitContainerStateChangeCommandInput, SubmitContainerStateChangeCommandOutput, ECSClientResolvedConfig> {
     readonly input: SubmitContainerStateChangeCommandInput;
     constructor(input: SubmitContainerStateChangeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SubmitContainerStateChangeCommandInput, SubmitContainerStateChangeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface SubmitTaskStateChangeCommandInput extends SubmitTaskStateChange
 }
 export interface SubmitTaskStateChangeCommandOutput extends SubmitTaskStateChangeResponse, __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>Sent to acknowledge
- * 			that a task changed states.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, SubmitTaskStateChangeCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, SubmitTaskStateChangeCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new SubmitTaskStateChangeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SubmitTaskStateChangeCommandInput} for command's `input` shape.
- * @see {@link SubmitTaskStateChangeCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SubmitTaskStateChangeCommand extends $Command<SubmitTaskStateChangeCommandInput, SubmitTaskStateChangeCommandOutput, ECSClientResolvedConfig> {
     readonly input: SubmitTaskStateChangeCommandInput;
     constructor(input: SubmitTaskStateChangeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SubmitTaskStateChangeCommandInput, SubmitTaskStateChangeCommandOutput>;
     private serialize;
     private deserialize;