@aws-sdk/client-ecs 3.36.0 → 3.39.0

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

@@ -6,32 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Associates the specified tags to a resource with the specified
- * 				<code>resourceArn</code>. If existing tags on a resource are not specified in the
- * 			request parameters, they are not changed. When a resource is deleted, the tags
- * 			associated with that resource are deleted as well.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, TagResourceCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, TagResourceCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ECSClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,44 +6,11 @@ export interface UpdateContainerAgentCommandInput extends UpdateContainerAgentRe
 }
 export interface UpdateContainerAgentCommandOutput extends UpdateContainerAgentResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the Amazon ECS container agent on a specified container instance. Updating the
- * 			Amazon ECS container agent does not interrupt running tasks or services on the container
- * 			instance. The process for updating the agent differs depending on whether your container
- * 			instance was launched with the Amazon ECS-optimized AMI or another operating system.</p>
- * 		       <note>
- * 			         <p>The <code>UpdateContainerAgent</code> API isn't supported for container instances
- * 				using the Amazon ECS-optimized Amazon Linux 2 (arm64) AMI. To update the container agent,
- * 				you can update the <code>ecs-init</code> package which will update the agent. For
- * 				more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/agent-update-ecs-ami.html">Updating the
- * 					Amazon ECS container agent</a> in the
- * 				<i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * 		       </note>
- * 		       <p>The <code>UpdateContainerAgent</code> API requires an Amazon ECS-optimized AMI or Amazon
- * 			Linux AMI with the <code>ecs-init</code> service installed and running. For help
- * 			updating the Amazon ECS container agent on other operating systems, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html#manually_update_agent">Manually updating the Amazon ECS container agent</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, UpdateContainerAgentCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, UpdateContainerAgentCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new UpdateContainerAgentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateContainerAgentCommandInput} for command's `input` shape.
- * @see {@link UpdateContainerAgentCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateContainerAgentCommand extends $Command<UpdateContainerAgentCommandInput, UpdateContainerAgentCommandOutput, ECSClientResolvedConfig> {
     readonly input: UpdateContainerAgentCommandInput;
     constructor(input: UpdateContainerAgentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateContainerAgentCommandInput, UpdateContainerAgentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,77 +6,11 @@ export interface UpdateContainerInstancesStateCommandInput extends UpdateContain
 }
 export interface UpdateContainerInstancesStateCommandOutput extends UpdateContainerInstancesStateResponse, __MetadataBearer {
 }
-/**
- * <p>Modifies the status of an Amazon ECS container instance.</p>
- * 		       <p>Once a container instance has reached an <code>ACTIVE</code> state, you can change the
- * 			status of a container instance to <code>DRAINING</code> to manually remove an instance
- * 			from a cluster, for example to perform system updates, update the Docker daemon, or
- * 			scale down the cluster size.</p>
- * 		       <important>
- * 			         <p>A container instance cannot be changed to <code>DRAINING</code> until it has
- * 				reached an <code>ACTIVE</code> status. If the instance is in any other status, an
- * 				error will be received.</p>
- * 		       </important>
- * 		       <p>When you set a container instance to <code>DRAINING</code>, Amazon ECS prevents new tasks
- * 			from being scheduled for placement on the container instance and replacement service
- * 			tasks are started on other container instances in the cluster if the resources are
- * 			available. Service tasks on the container instance that are in the <code>PENDING</code>
- * 			state are stopped immediately.</p>
- * 		       <p>Service tasks on the container instance that are in the <code>RUNNING</code> state are
- * 			stopped and replaced according to the service's deployment configuration parameters,
- * 				<code>minimumHealthyPercent</code> and <code>maximumPercent</code>. You can change
- * 			the deployment configuration of your service using <a>UpdateService</a>.</p>
- * 		       <ul>
- *             <li>
- * 				           <p>If <code>minimumHealthyPercent</code> is below 100%, the scheduler can ignore
- * 						<code>desiredCount</code> temporarily during task replacement. For example,
- * 						<code>desiredCount</code> is four tasks, a minimum of 50% allows the
- * 					scheduler to stop two existing tasks before starting two new tasks. If the
- * 					minimum is 100%, the service scheduler can't remove existing tasks until the
- * 					replacement tasks are considered healthy. Tasks for services that do not use a
- * 					load balancer are considered healthy if they are in the <code>RUNNING</code>
- * 					state. Tasks for services that use a load balancer are considered healthy if
- * 					they are in the <code>RUNNING</code> state and the container instance they are
- * 					hosted on is reported as healthy by the load balancer.</p>
- * 			         </li>
- *             <li>
- * 				           <p>The <code>maximumPercent</code> parameter represents an upper limit on the
- * 					number of running tasks during task replacement, which enables you to define the
- * 					replacement batch size. For example, if <code>desiredCount</code> is four tasks,
- * 					a maximum of 200% starts four new tasks before stopping the four tasks to be
- * 					drained, provided that the cluster resources required to do this are available.
- * 					If the maximum is 100%, then replacement tasks can't start until the draining
- * 					tasks have stopped.</p>
- * 			         </li>
- *          </ul>
- * 		       <p>Any <code>PENDING</code> or <code>RUNNING</code> tasks that do not belong to a service
- * 			are not affected. You must wait for them to finish or stop them manually.</p>
- * 		       <p>A container instance has completed draining when it has no more <code>RUNNING</code>
- * 			tasks. You can verify this using <a>ListTasks</a>.</p>
- * 		       <p>When a container instance has been drained, you can set a container instance to
- * 				<code>ACTIVE</code> status and once it has reached that status the Amazon ECS scheduler
- * 			can begin scheduling tasks on the instance again.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, UpdateContainerInstancesStateCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, UpdateContainerInstancesStateCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new UpdateContainerInstancesStateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateContainerInstancesStateCommandInput} for command's `input` shape.
- * @see {@link UpdateContainerInstancesStateCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateContainerInstancesStateCommand extends $Command<UpdateContainerInstancesStateCommandInput, UpdateContainerInstancesStateCommandOutput, ECSClientResolvedConfig> {
     readonly input: UpdateContainerInstancesStateCommandInput;
     constructor(input: UpdateContainerInstancesStateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateContainerInstancesStateCommandInput, UpdateContainerInstancesStateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,137 +6,11 @@ export interface UpdateServiceCommandInput extends UpdateServiceRequest {
 }
 export interface UpdateServiceCommandOutput extends UpdateServiceResponse, __MetadataBearer {
 }
-/**
- * <important>
- * 			         <p>Updating the task placement strategies and constraints on an Amazon ECS service remains
- * 				in preview and is a Beta Service as defined by and subject to the Beta Service
- * 				Participation Service Terms located at <a href="https://aws.amazon.com/service-terms">https://aws.amazon.com/service-terms</a> ("Beta Terms"). These Beta Terms
- * 				apply to your participation in this preview.</p>
- * 		       </important>
- * 		       <p>Modifies the parameters of a service.</p>
- * 		       <p>For services using the rolling update (<code>ECS</code>) deployment controller, the
- * 			desired count, deployment configuration, network configuration, task placement
- * 			constraints and strategies, or task definition used can be updated.</p>
- * 		       <p>For services using the blue/green (<code>CODE_DEPLOY</code>) deployment controller,
- * 			only the desired count, deployment configuration, task placement constraints and
- * 			strategies, and health check grace period can be updated using this API. If the network
- * 			configuration, platform version, or task definition need to be updated, a new CodeDeploy
- * 			deployment should be created. For more information, see <a href="https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeployment.html">CreateDeployment</a> in the <i>CodeDeploy API Reference</i>.</p>
- * 		       <p>For services using an external deployment controller, you can update only the desired
- * 			count, task placement constraints and strategies, and health check grace period using
- * 			this API. If the launch type, load balancer, network configuration, platform version, or
- * 			task definition need to be updated, you should create a new task set. For more
- * 			information, see <a>CreateTaskSet</a>.</p>
- * 		       <p>You can add to or subtract from the number of instantiations of a task definition in a
- * 			service by specifying the cluster that the service is running in and a new
- * 				<code>desiredCount</code> parameter.</p>
- * 		       <p>If you have updated the Docker image of your application, you can create a new task
- * 			definition with that image and deploy it to your service. The service scheduler uses the
- * 			minimum healthy percent and maximum percent parameters (in the service's deployment
- * 			configuration) to determine the deployment strategy.</p>
- * 		       <note>
- * 			         <p>If your updated Docker image uses the same tag as what is in the existing task
- * 				definition for your service (for example, <code>my_image:latest</code>), you do not
- * 				need to create a new revision of your task definition. You can update the service
- * 				using the <code>forceNewDeployment</code> option. The new tasks launched by the
- * 				deployment pull the current image/tag combination from your repository when they
- * 				start.</p>
- * 		       </note>
- * 		       <p>You can also update the deployment configuration of a service. When a deployment is
- * 			triggered by updating the task definition of a service, the service scheduler uses the
- * 			deployment configuration parameters, <code>minimumHealthyPercent</code> and
- * 				<code>maximumPercent</code>, to determine the deployment strategy.</p>
- * 		       <ul>
- *             <li>
- * 				           <p>If <code>minimumHealthyPercent</code> is below 100%, the scheduler can ignore
- * 						<code>desiredCount</code> temporarily during a deployment. For example, if
- * 						<code>desiredCount</code> is four tasks, a minimum of 50% allows the
- * 					scheduler to stop two existing tasks before starting two new tasks. Tasks for
- * 					services that do not use a load balancer are considered healthy if they are in
- * 					the <code>RUNNING</code> state. Tasks for services that use a load balancer are
- * 					considered healthy if they are in the <code>RUNNING</code> state and the
- * 					container instance they are hosted on is reported as healthy by the load
- * 					balancer.</p>
- * 			         </li>
- *             <li>
- * 				           <p>The <code>maximumPercent</code> parameter represents an upper limit on the
- * 					number of running tasks during a deployment, which enables you to define the
- * 					deployment batch size. For example, if <code>desiredCount</code> is four tasks,
- * 					a maximum of 200% starts four new tasks before stopping the four older tasks
- * 					(provided that the cluster resources required to do this are available).</p>
- * 			         </li>
- *          </ul>
- * 		       <p>When <a>UpdateService</a> stops a task during a deployment, the equivalent
- * 			of <code>docker stop</code> is issued to the containers running in the task. This
- * 			results in a <code>SIGTERM</code> and a 30-second timeout, after which
- * 				<code>SIGKILL</code> is sent and the containers are forcibly stopped. If the
- * 			container handles the <code>SIGTERM</code> gracefully and exits within 30 seconds from
- * 			receiving it, no <code>SIGKILL</code> is sent.</p>
- * 		       <p>When the service scheduler launches new tasks, it determines task placement in your
- * 			cluster with the following logic:</p>
- * 		       <ul>
- *             <li>
- * 				           <p>Determine which of the container instances in your cluster can support your
- * 					service's task definition (for example, they have the required CPU, memory,
- * 					ports, and container instance attributes).</p>
- * 			         </li>
- *             <li>
- * 				           <p>By default, the service scheduler attempts to balance tasks across
- * 					Availability Zones in this manner (although you can choose a different placement
- * 					strategy):</p>
- * 				           <ul>
- *                   <li>
- * 						               <p>Sort the valid container instances by the fewest number of running
- * 							tasks for this service in the same Availability Zone as the instance.
- * 							For example, if zone A has one running service task and zones B and C
- * 							each have zero, valid container instances in either zone B or C are
- * 							considered optimal for placement.</p>
- * 					             </li>
- *                   <li>
- * 						               <p>Place the new service task on a valid container instance in an optimal
- * 							Availability Zone (based on the previous steps), favoring container
- * 							instances with the fewest number of running tasks for this
- * 							service.</p>
- * 					             </li>
- *                </ul>
- * 			         </li>
- *          </ul>
- * 		       <p>When the service scheduler stops running tasks, it attempts to maintain balance across
- * 			the Availability Zones in your cluster using the following logic: </p>
- * 		       <ul>
- *             <li>
- * 				           <p>Sort the container instances by the largest number of running tasks for this
- * 					service in the same Availability Zone as the instance. For example, if zone A
- * 					has one running service task and zones B and C each have two, container
- * 					instances in either zone B or C are considered optimal for termination.</p>
- * 			         </li>
- *             <li>
- * 				           <p>Stop the task on a container instance in an optimal Availability Zone (based
- * 					on the previous steps), favoring container instances with the largest number of
- * 					running tasks for this service.</p>
- * 			         </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, UpdateServiceCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, UpdateServiceCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new UpdateServiceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateServiceCommandInput} for command's `input` shape.
- * @see {@link UpdateServiceCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateServiceCommand extends $Command<UpdateServiceCommandInput, UpdateServiceCommandOutput, ECSClientResolvedConfig> {
     readonly input: UpdateServiceCommandInput;
     constructor(input: UpdateServiceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateServiceCommandInput, UpdateServiceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface UpdateServicePrimaryTaskSetCommandInput extends UpdateServicePr
 }
 export interface UpdateServicePrimaryTaskSetCommandOutput extends UpdateServicePrimaryTaskSetResponse, __MetadataBearer {
 }
-/**
- * <p>Modifies which task set in a service is the primary task set. Any parameters that are
- * 			updated on the primary task set in a service will transition to the 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, UpdateServicePrimaryTaskSetCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, UpdateServicePrimaryTaskSetCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new UpdateServicePrimaryTaskSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateServicePrimaryTaskSetCommandInput} for command's `input` shape.
- * @see {@link UpdateServicePrimaryTaskSetCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateServicePrimaryTaskSetCommand extends $Command<UpdateServicePrimaryTaskSetCommandInput, UpdateServicePrimaryTaskSetCommandOutput, ECSClientResolvedConfig> {
     readonly input: UpdateServicePrimaryTaskSetCommandInput;
     constructor(input: UpdateServicePrimaryTaskSetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateServicePrimaryTaskSetCommandInput, UpdateServicePrimaryTaskSetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface UpdateTaskSetCommandInput extends UpdateTaskSetRequest {
 }
 export interface UpdateTaskSetCommandOutput extends UpdateTaskSetResponse, __MetadataBearer {
 }
-/**
- * <p>Modifies a task set. 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, UpdateTaskSetCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, UpdateTaskSetCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new UpdateTaskSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateTaskSetCommandInput} for command's `input` shape.
- * @see {@link UpdateTaskSetCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateTaskSetCommand extends $Command<UpdateTaskSetCommandInput, UpdateTaskSetCommandOutput, ECSClientResolvedConfig> {
     readonly input: UpdateTaskSetCommandInput;
     constructor(input: UpdateTaskSetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateTaskSetCommandInput, UpdateTaskSetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,52 @@
+export * from "./CreateCapacityProviderCommand";
+export * from "./CreateClusterCommand";
+export * from "./CreateServiceCommand";
+export * from "./CreateTaskSetCommand";
+export * from "./DeleteAccountSettingCommand";
+export * from "./DeleteAttributesCommand";
+export * from "./DeleteCapacityProviderCommand";
+export * from "./DeleteClusterCommand";
+export * from "./DeleteServiceCommand";
+export * from "./DeleteTaskSetCommand";
+export * from "./DeregisterContainerInstanceCommand";
+export * from "./DeregisterTaskDefinitionCommand";
+export * from "./DescribeCapacityProvidersCommand";
+export * from "./DescribeClustersCommand";
+export * from "./DescribeContainerInstancesCommand";
+export * from "./DescribeServicesCommand";
+export * from "./DescribeTaskDefinitionCommand";
+export * from "./DescribeTaskSetsCommand";
+export * from "./DescribeTasksCommand";
+export * from "./DiscoverPollEndpointCommand";
+export * from "./ExecuteCommandCommand";
+export * from "./ListAccountSettingsCommand";
+export * from "./ListAttributesCommand";
+export * from "./ListClustersCommand";
+export * from "./ListContainerInstancesCommand";
+export * from "./ListServicesCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./ListTaskDefinitionFamiliesCommand";
+export * from "./ListTaskDefinitionsCommand";
+export * from "./ListTasksCommand";
+export * from "./PutAccountSettingCommand";
+export * from "./PutAccountSettingDefaultCommand";
+export * from "./PutAttributesCommand";
+export * from "./PutClusterCapacityProvidersCommand";
+export * from "./RegisterContainerInstanceCommand";
+export * from "./RegisterTaskDefinitionCommand";
+export * from "./RunTaskCommand";
+export * from "./StartTaskCommand";
+export * from "./StopTaskCommand";
+export * from "./SubmitAttachmentStateChangesCommand";
+export * from "./SubmitContainerStateChangeCommand";
+export * from "./SubmitTaskStateChangeCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateCapacityProviderCommand";
+export * from "./UpdateClusterCommand";
+export * from "./UpdateClusterSettingsCommand";
+export * from "./UpdateContainerAgentCommand";
+export * from "./UpdateContainerInstancesStateCommand";
+export * from "./UpdateServiceCommand";
+export * from "./UpdateServicePrimaryTaskSetCommand";
+export * from "./UpdateTaskSetCommand";

package/dist-types/ts3.4/index.d.ts

@@ -1,67 +1,6 @@
-export * from "./ECSClient";
 export * from "./ECS";
-export * from "./commands/CreateCapacityProviderCommand";
-export * from "./commands/CreateClusterCommand";
-export * from "./commands/CreateServiceCommand";
-export * from "./commands/CreateTaskSetCommand";
-export * from "./commands/DeleteAccountSettingCommand";
-export * from "./commands/DeleteAttributesCommand";
-export * from "./commands/DeleteCapacityProviderCommand";
-export * from "./commands/DeleteClusterCommand";
-export * from "./commands/DeleteServiceCommand";
-export * from "./commands/DeleteTaskSetCommand";
-export * from "./commands/DeregisterContainerInstanceCommand";
-export * from "./commands/DeregisterTaskDefinitionCommand";
-export * from "./commands/DescribeCapacityProvidersCommand";
-export * from "./commands/DescribeClustersCommand";
-export * from "./commands/DescribeContainerInstancesCommand";
-export * from "./commands/DescribeServicesCommand";
-export * from "./waiters/waitForServicesInactive";
-export * from "./commands/DescribeTaskDefinitionCommand";
-export * from "./commands/DescribeTasksCommand";
-export * from "./waiters/waitForTasksRunning";
-export * from "./waiters/waitForTasksStopped";
-export * from "./commands/DescribeTaskSetsCommand";
-export * from "./commands/DiscoverPollEndpointCommand";
-export * from "./commands/ExecuteCommandCommand";
-export * from "./commands/ListAccountSettingsCommand";
-export * from "./pagination/ListAccountSettingsPaginator";
-export * from "./commands/ListAttributesCommand";
-export * from "./pagination/ListAttributesPaginator";
-export * from "./commands/ListClustersCommand";
-export * from "./pagination/ListClustersPaginator";
-export * from "./commands/ListContainerInstancesCommand";
-export * from "./pagination/ListContainerInstancesPaginator";
-export * from "./commands/ListServicesCommand";
-export * from "./pagination/ListServicesPaginator";
-export * from "./commands/ListTagsForResourceCommand";
-export * from "./commands/ListTaskDefinitionFamiliesCommand";
-export * from "./pagination/ListTaskDefinitionFamiliesPaginator";
-export * from "./commands/ListTaskDefinitionsCommand";
-export * from "./pagination/ListTaskDefinitionsPaginator";
-export * from "./commands/ListTasksCommand";
-export * from "./pagination/ListTasksPaginator";
-export * from "./commands/PutAccountSettingCommand";
-export * from "./commands/PutAccountSettingDefaultCommand";
-export * from "./commands/PutAttributesCommand";
-export * from "./commands/PutClusterCapacityProvidersCommand";
-export * from "./commands/RegisterContainerInstanceCommand";
-export * from "./commands/RegisterTaskDefinitionCommand";
-export * from "./commands/RunTaskCommand";
-export * from "./commands/StartTaskCommand";
-export * from "./commands/StopTaskCommand";
-export * from "./commands/SubmitAttachmentStateChangesCommand";
-export * from "./commands/SubmitContainerStateChangeCommand";
-export * from "./commands/SubmitTaskStateChangeCommand";
-export * from "./commands/TagResourceCommand";
-export * from "./commands/UntagResourceCommand";
-export * from "./commands/UpdateCapacityProviderCommand";
-export * from "./commands/UpdateClusterCommand";
-export * from "./commands/UpdateClusterSettingsCommand";
-export * from "./commands/UpdateContainerAgentCommand";
-export * from "./commands/UpdateContainerInstancesStateCommand";
-export * from "./commands/UpdateServiceCommand";
-export * from "./commands/UpdateServicePrimaryTaskSetCommand";
-export * from "./commands/UpdateTaskSetCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./ECSClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export * from "./waiters";