@aws-sdk/client-ecs 3.40.0 → 3.45.0

package/dist-types/ECS.d.ts

@@ -54,28 +54,28 @@ import { UpdateTaskSetCommandInput, UpdateTaskSetCommandOutput } from "./command
 import { ECSClient } from "./ECSClient";
 /**
  * <fullname>Amazon Elastic Container Service</fullname>
- * 		       <p>Amazon Elastic Container Service (Amazon ECS) is a highly scalable, fast, container management service that makes
+ * 		       <p>Amazon Elastic Container Service (Amazon ECS) is a highly scalable, fast, container management service. It makes
  * 			it easy to run, stop, and manage Docker containers on a cluster. You can host your
- * 			cluster on a serverless infrastructure that is managed by Amazon ECS by launching your
+ * 			cluster on a serverless infrastructure that's managed by Amazon ECS by launching your
  * 			services or tasks on Fargate. For more control, you can host your tasks on a cluster
  * 			of Amazon Elastic Compute Cloud (Amazon EC2) instances that you manage.</p>
  * 		       <p>Amazon ECS makes it easy to launch and stop container-based applications with simple API
- * 			calls, allows you to get the state of your cluster from a centralized service, and gives
- * 			you access to many familiar Amazon EC2 features.</p>
+ * 			calls. This makes it easy to get the state of your cluster from a centralized service,
+ * 			and gives you access to many familiar Amazon EC2 features.</p>
  * 		       <p>You can use Amazon ECS to schedule the placement of containers across your cluster based on
- * 			your resource needs, isolation policies, and availability requirements. Amazon ECS eliminates
- * 			the need for you to operate your own cluster management and configuration management
- * 			systems or worry about scaling your management infrastructure.</p>
+ * 			your resource needs, isolation policies, and availability requirements. With Amazon ECS, you
+ * 			don't need to operate your own cluster management and configuration management systems.
+ * 			You also don't need to worry about scaling your management infrastructure.</p>
  */
 export declare class ECS extends ECSClient {
     /**
      * <p>Creates a new capacity provider. Capacity providers are associated with an Amazon ECS
      * 			cluster and are used in capacity provider strategies to facilitate cluster auto
      * 			scaling.</p>
-     * 		       <p>Only capacity providers using an Auto Scaling group can be created. Amazon ECS tasks on
-     * 			Fargate use the <code>FARGATE</code> and <code>FARGATE_SPOT</code> capacity providers
-     * 			which are already created and available to all accounts in Regions supported by
-     * 			Fargate.</p>
+     * 		       <p>Only capacity providers that use an Auto Scaling group can be created. Amazon ECS tasks on
+     * 			Fargate use the <code>FARGATE</code> and <code>FARGATE_SPOT</code> capacity providers.
+     * 			These providers are available to all accounts in the Amazon Web Services Regions that Fargate
+     * 			supports.</p>
      */
     createCapacityProvider(args: CreateCapacityProviderCommandInput, options?: __HttpHandlerOptions): Promise<CreateCapacityProviderCommandOutput>;
     createCapacityProvider(args: CreateCapacityProviderCommandInput, cb: (err: any, data?: CreateCapacityProviderCommandOutput) => void): void;
@@ -86,10 +86,10 @@ export declare class ECS extends ECSClient {
      * 			cluster with a unique name with the <code>CreateCluster</code> action.</p>
      * 		       <note>
      * 			         <p>When you call the <a>CreateCluster</a> API operation, Amazon ECS attempts to
-     * 				create the Amazon ECS service-linked role for your account so that required resources in
-     * 				other Amazon Web Services services can be managed on your behalf. However, if the IAM user that
-     * 				makes the call does not have permissions to create the service-linked role, it is
-     * 				not created. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html">Using
+     * 				create the Amazon ECS service-linked role for your account. This is so that it can manage
+     * 				required resources in other Amazon Web Services services on your behalf. However, if the IAM user
+     * 				that makes the call doesn't have permissions to create the service-linked role, it
+     * 				isn't created. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html">Using
      * 					Service-Linked Roles for Amazon ECS</a> in the
      * 					<i>Amazon Elastic Container Service Developer Guide</i>.</p>
      * 		       </note>
@@ -98,26 +98,25 @@ export declare class ECS extends ECSClient {
     createCluster(args: CreateClusterCommandInput, cb: (err: any, data?: CreateClusterCommandOutput) => void): void;
     createCluster(args: CreateClusterCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateClusterCommandOutput) => void): void;
     /**
-     * <p>Runs and maintains a desired number of tasks from a specified task definition. If the
-     * 			number of tasks running in a service drops below the <code>desiredCount</code>, Amazon ECS
-     * 			runs another copy of the task in the specified cluster. To update an existing service,
-     * 			see the UpdateService action.</p>
+     * <p>Runs and maintains your desired number of tasks from a specified task definition. If
+     * 			the number of tasks running in a service drops below the <code>desiredCount</code>,
+     * 			Amazon ECS runs another copy of the task in the specified cluster. To update an existing
+     * 			service, see the UpdateService action.</p>
      * 		       <p>In addition to maintaining the desired count of tasks in your service, you can
      * 			optionally run your service behind one or more load balancers. The load balancers
      * 			distribute traffic across the tasks that are associated with the service. For more
      * 			information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html">Service Load Balancing</a> in the
      * 				<i>Amazon Elastic Container Service Developer Guide</i>.</p>
-     * 		       <p>Tasks for services that <i>do not</i> use a load balancer are considered
-     * 			healthy if they're in the <code>RUNNING</code> state. Tasks for services that
-     * 				<i>do</i> use a load balancer are considered healthy if they're in the
-     * 				<code>RUNNING</code> state and the container instance that they're hosted on is
-     * 			reported as healthy by the load balancer.</p>
+     * 		       <p>Tasks for services that don't use a load balancer are considered healthy if they're in
+     * 			the <code>RUNNING</code> state. Tasks for services that use a load balancer are
+     * 			considered healthy if they're in the <code>RUNNING</code> state and the container
+     * 			instance that they're hosted on is reported as healthy by the load balancer.</p>
      * 		       <p>There are two service scheduler strategies available:</p>
      * 		       <ul>
      *             <li>
      * 				           <p>
      *                   <code>REPLICA</code> - The replica scheduling strategy places and
-     * 					maintains the desired number of tasks across your cluster. By default, the
+     * 					maintains your desired number of tasks across your cluster. By default, the
      * 					service scheduler spreads tasks across Availability Zones. You can use task
      * 					placement strategies and constraints to customize task placement decisions. For
      * 					more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service Scheduler Concepts</a> in the
@@ -128,50 +127,51 @@ export declare class ECS extends ECSClient {
      *                   <code>DAEMON</code> - The daemon scheduling strategy deploys exactly one
      * 					task on each active container instance that meets all of the task placement
      * 					constraints that you specify in your cluster. The service scheduler also
-     * 					evaluates the task placement constraints for running tasks and will stop tasks
-     * 					that do not meet the placement constraints. When using this strategy, you don't
+     * 					evaluates the task placement constraints for running tasks. It also stops tasks
+     * 					that don't meet the placement constraints. When using this strategy, you don't
      * 					need to specify a desired number of tasks, a task placement strategy, or use
      * 					Service Auto Scaling policies. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html">Service Scheduler Concepts</a> in the
      * 						<i>Amazon Elastic Container Service Developer Guide</i>.</p>
      * 			         </li>
      *          </ul>
      * 		       <p>You can optionally specify a deployment configuration for your service. The deployment
-     * 			is triggered by changing properties, such as the task definition or the desired count of
-     * 			a service, with an <a>UpdateService</a> operation. The default value for a
-     * 			replica service for <code>minimumHealthyPercent</code> is 100%. The default value for a
-     * 			daemon service for <code>minimumHealthyPercent</code> is 0%.</p>
-     * 		       <p>If a service is using the <code>ECS</code> deployment controller, the minimum healthy
+     * 			is initiated by changing properties. For example, the deployment might be initiated by
+     * 			the task definition or by your desired count of a service. This is done with an <a>UpdateService</a> operation. The default value for a replica service for
+     * 				<code>minimumHealthyPercent</code> is 100%. The default value for a daemon service
+     * 			for <code>minimumHealthyPercent</code> is 0%.</p>
+     * 		       <p>If a service uses the <code>ECS</code> deployment controller, the minimum healthy
      * 			percent represents a lower limit on the number of tasks in a service that must remain in
-     * 			the <code>RUNNING</code> state during a deployment, as a percentage of the desired
-     * 			number of tasks (rounded up to the nearest integer), and while any container instances
-     * 			are in the <code>DRAINING</code> state if the service contains tasks using the
-     * 			EC2 launch type. This parameter enables you to deploy without using
-     * 			additional cluster capacity. For example, if your service has a desired number of four
-     * 			tasks and a minimum healthy percent of 50%, the scheduler might stop two existing tasks
-     * 			to free up cluster capacity before starting two new tasks. Tasks for services that
-     * 				<i>do not</i> use a load balancer are considered healthy if they're in
-     * 			the <code>RUNNING</code> state. Tasks for services that <i>do</i> use a
-     * 			load balancer are considered healthy if they're in the <code>RUNNING</code> state and
-     * 			they're reported as healthy by the load balancer. The default value for minimum healthy
-     * 			percent is 100%.</p>
-     * 		       <p>If a service is using the <code>ECS</code> deployment controller, the <b>maximum percent</b> parameter represents an upper limit on the
+     * 			the <code>RUNNING</code> state during a deployment. Specifically, it represents it as a
+     * 			percentage of your desired number of tasks (rounded up to the nearest integer). This
+     * 			happens when any of your container instances are in the <code>DRAINING</code> state if
+     * 			the service contains tasks using the EC2 launch type. Using this
+     * 			parameter, you can deploy without using additional cluster capacity. For example, if you
+     * 			set your service to have desired number of four tasks and a minimum healthy percent of
+     * 			50%, the scheduler might stop two existing tasks to free up cluster capacity before
+     * 			starting two new tasks. If they're in the <code>RUNNING</code> state, tasks for services
+     * 			that don't use a load balancer are considered healthy . If they're in the
+     * 				<code>RUNNING</code> state and reported as healthy by the load balancer, tasks for
+     * 			services that <i>do</i> use a load balancer are considered healthy . The
+     * 			default value for minimum healthy percent is 100%.</p>
+     * 		       <p>If a service uses the <code>ECS</code> deployment controller, the <b>maximum percent</b> parameter represents an upper limit on the
      * 			number of tasks in a service that are allowed in the <code>RUNNING</code> or
-     * 				<code>PENDING</code> state during a deployment, as a percentage of the desired
-     * 			number of tasks (rounded down to the nearest integer), and while any container instances
-     * 			are in the <code>DRAINING</code> state if the service contains tasks using the
-     * 			EC2 launch type. This parameter enables you to define the deployment batch
-     * 			size. For example, if your service has a desired number of four tasks and a maximum
-     * 			percent value of 200%, the scheduler may start four new tasks before stopping the four
-     * 			older tasks (provided that the cluster resources required to do this are available). The
-     * 			default value for maximum percent is 200%.</p>
-     * 		       <p>If a service is using either the <code>CODE_DEPLOY</code> or <code>EXTERNAL</code>
+     * 				<code>PENDING</code> state during a deployment. Specifically, it represents it as a
+     * 			percentage of the desired number of tasks (rounded down to the nearest integer). This
+     * 			happens when any of your container instances are in the <code>DRAINING</code> state if
+     * 			the service contains tasks using the EC2 launch type. Using this
+     * 			parameter, you can define the deployment batch size. For example, if your service has a
+     * 			desired number of four tasks and a maximum percent value of 200%, the scheduler may
+     * 			start four new tasks before stopping the four older tasks (provided that the cluster
+     * 			resources required to do this are available). The default value for maximum percent is
+     * 			200%.</p>
+     * 		       <p>If a service uses either the <code>CODE_DEPLOY</code> or <code>EXTERNAL</code>
      * 			deployment controller types and tasks that use the EC2 launch type, the
      * 				<b>minimum healthy percent</b> and <b>maximum percent</b> values are used only to define the lower and upper limit
-     * 			on the number of the tasks in the service that remain in the <code>RUNNING</code> state
-     * 			while the container instances are in the <code>DRAINING</code> state. If the tasks in
-     * 			the service use the Fargate launch type, the minimum healthy percent and
-     * 			maximum percent values aren't used, although they're currently visible when describing
-     * 			your service.</p>
+     * 			on the number of the tasks in the service that remain in the <code>RUNNING</code> state.
+     * 			This is while the container instances are in the <code>DRAINING</code> state. If the
+     * 			tasks in the service use the Fargate launch type, the minimum healthy
+     * 			percent and maximum percent values aren't used. This is the case even if they're
+     * 			currently visible when describing your service.</p>
      * 		       <p>When creating a service that uses the <code>EXTERNAL</code> deployment controller, you
      * 			can specify only parameters that aren't controlled at the task set level. The only
      * 			required parameter is the service name. You control your services using the <a>CreateTaskSet</a> operation. 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>
@@ -179,14 +179,15 @@ export declare class ECS extends ECSClient {
      * 			cluster using 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>
+     * 				           <p>Determine which of the container instances in your cluster can support the
+     * 					task definition of your service. 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) with the <code>placementStrategy</code> parameter):</p>
+     * 					Availability Zones in this manner. This is the case even if you can choose a
+     * 					different placement strategy with the <code>placementStrategy</code>
+     * 					parameter.</p>
      * 				           <ul>
      *                   <li>
      * 						               <p>Sort the valid container instances, giving priority to instances that
@@ -197,7 +198,7 @@ export declare class ECS extends ECSClient {
      * 					             </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
+     * 							Availability Zone based on the previous steps, favoring container
      * 							instances with the fewest number of running tasks for this
      * 							service.</p>
      * 					             </li>
@@ -234,8 +235,8 @@ export declare class ECS extends ECSClient {
      * <p>Deletes the specified capacity provider.</p>
      * 		       <note>
      * 			         <p>The <code>FARGATE</code> and <code>FARGATE_SPOT</code> capacity providers are
-     * 				reserved and cannot be deleted. You can disassociate them from a cluster using
-     * 				either the <a>PutClusterCapacityProviders</a> API or by deleting the
+     * 				reserved and can't be deleted. You can disassociate them from a cluster using either
+     * 				the <a>PutClusterCapacityProviders</a> API or by deleting the
      * 				cluster.</p>
      * 		       </note>
      * 		       <p>Prior to a capacity provider being deleted, the capacity provider must be removed from
@@ -244,18 +245,17 @@ export declare class ECS extends ECSClient {
      * 			strategy. When updating a service, the <code>forceNewDeployment</code> option can be
      * 			used to ensure that any tasks using the Amazon EC2 instance capacity provided by the capacity
      * 			provider are transitioned to use the capacity from the remaining capacity providers.
-     * 			Only capacity providers that are not associated with a cluster can be deleted. To remove
+     * 			Only capacity providers that aren't associated with a cluster can be deleted. To remove
      * 			a capacity provider from a cluster, you can either use <a>PutClusterCapacityProviders</a> or delete the cluster.</p>
      */
     deleteCapacityProvider(args: DeleteCapacityProviderCommandInput, options?: __HttpHandlerOptions): Promise<DeleteCapacityProviderCommandOutput>;
     deleteCapacityProvider(args: DeleteCapacityProviderCommandInput, cb: (err: any, data?: DeleteCapacityProviderCommandOutput) => void): void;
     deleteCapacityProvider(args: DeleteCapacityProviderCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteCapacityProviderCommandOutput) => void): void;
     /**
-     * <p>Deletes the specified cluster. The cluster will transition to the
-     * 				<code>INACTIVE</code> state. Clusters with an <code>INACTIVE</code> status may
-     * 			remain discoverable in your account for a period of time. However, this behavior is
-     * 			subject to change in the future, so you should not rely on <code>INACTIVE</code>
-     * 			clusters persisting.</p>
+     * <p>Deletes the specified cluster. The cluster transitions to the <code>INACTIVE</code>
+     * 			state. Clusters with an <code>INACTIVE</code> status might remain discoverable in your
+     * 			account for a period of time. However, this behavior is subject to change in the future.
+     * 			We don't recommend that you rely on <code>INACTIVE</code> clusters persisting.</p>
      * 		       <p>You must deregister all container instances from this cluster before you may delete
      * 			it. You can list the container instances in a cluster with <a>ListContainerInstances</a> and deregister them with <a>DeregisterContainerInstance</a>.</p>
      */
@@ -265,7 +265,7 @@ export declare class ECS extends ECSClient {
     /**
      * <p>Deletes a specified service within a cluster. You can delete a service if you have no
      * 			running tasks in it and the desired task count is zero. If the service is actively
-     * 			maintaining tasks, you cannot delete it, and you must update the service to a desired
+     * 			maintaining tasks, you can't delete it, and you must update the service to a desired
      * 			task count of zero. For more information, see <a>UpdateService</a>.</p>
      * 		       <note>
      * 			         <p>When you delete a service, if there are still running tasks that require cleanup,
@@ -299,15 +299,16 @@ export declare class ECS extends ECSClient {
      * <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>
+     * 			deregistration, we recommend that you 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 doesn't
+     * 			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>
+     * 				disconnected agents aren't automatically deregistered when terminated).</p>
      * 		       </note>
      */
     deregisterContainerInstance(args: DeregisterContainerInstanceCommandInput, options?: __HttpHandlerOptions): Promise<DeregisterContainerInstanceCommandOutput>;
@@ -319,16 +320,15 @@ export declare class ECS extends ECSClient {
      * 			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>
+     * 		       <p>You can't use an <code>INACTIVE</code> task definition to run new tasks or create new
+     * 			services, and you can't 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>
+     * 				account indefinitely. However, this behavior is subject to change in the future. We
+     * 				don't recommend that you rely on <code>INACTIVE</code> task definitions persisting
+     * 				beyond the lifecycle of any associated tasks and services.</p>
      * 		       </note>
      */
     deregisterTaskDefinition(args: DeregisterTaskDefinitionCommandInput, options?: __HttpHandlerOptions): Promise<DeregisterTaskDefinitionCommandOutput>;
@@ -391,8 +391,7 @@ export declare class ECS extends ECSClient {
      * <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>
+     * 		       <p>Returns an endpoint for the Amazon ECS agent to poll for updates.</p>
      */
     discoverPollEndpoint(args: DiscoverPollEndpointCommandInput, options?: __HttpHandlerOptions): Promise<DiscoverPollEndpointCommandOutput>;
     discoverPollEndpoint(args: DiscoverPollEndpointCommandInput, cb: (err: any, data?: DiscoverPollEndpointCommandOutput) => void): void;
@@ -414,9 +413,9 @@ export declare class ECS extends ECSClient {
      * 			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>
+     * 			can also filter the results by attribute name and value. You can do this, for example,
+     * 			to see which container instances in a cluster are running a Linux AMI
+     * 				(<code>ecs.os-type=linux</code>). </p>
      */
     listAttributes(args: ListAttributesCommandInput, options?: __HttpHandlerOptions): Promise<ListAttributesCommandOutput>;
     listAttributes(args: ListAttributesCommandInput, cb: (err: any, data?: ListAttributesCommandOutput) => void): void;
@@ -450,12 +449,12 @@ export declare class ECS extends ECSClient {
     listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     /**
-     * <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
+     * <p>Returns a list of task definition families that are registered to your account. This
+     * 			list includes task definition families that no longer have any <code>ACTIVE</code> task
+     * 			definition revisions.</p>
+     * 		       <p>You can filter out task definition families that don't 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>
      */
     listTaskDefinitionFamilies(args: ListTaskDefinitionFamiliesCommandInput, options?: __HttpHandlerOptions): Promise<ListTaskDefinitionFamiliesCommandOutput>;
@@ -482,16 +481,16 @@ export declare class ECS extends ECSClient {
     /**
      * <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
+     * 			the IAM users and roles that no individual account setting was specified are reset for.
+     * 			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>
+     * 			set for each Amazon ECS resource separately. The ARN and resource ID format of a resource is
+     * 			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
@@ -517,8 +516,8 @@ export declare class ECS extends ECSClient {
     putAccountSettingDefault(args: PutAccountSettingDefaultCommandInput, cb: (err: any, data?: PutAccountSettingDefaultCommandOutput) => void): void;
     putAccountSettingDefault(args: PutAccountSettingDefaultCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutAccountSettingDefaultCommandOutput) => void): void;
     /**
-     * <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.
+     * <p>Create or update an attribute on an Amazon ECS resource. If the attribute doesn't exist,
+     * 			it's 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>
@@ -532,14 +531,14 @@ export declare class ECS extends ECSClient {
      * 		       <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>
+     * 			new ones you want to add. Any existing capacity providers that are 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
+     * 			We recommend that you define a default capacity provider strategy for your cluster.
+     * 			However, you must specify an empty array (<code>[]</code>) to bypass defining a default
      * 			strategy.</p>
      */
     putClusterCapacityProviders(args: PutClusterCapacityProvidersCommandInput, options?: __HttpHandlerOptions): Promise<PutClusterCapacityProvidersCommandOutput>;
@@ -549,9 +548,8 @@ export declare class ECS extends ECSClient {
      * <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>
+     * 		       <p>Registers an EC2 instance into the specified cluster. This instance becomes available
+     * 			to place containers on.</p>
      */
     registerContainerInstance(args: RegisterContainerInstanceCommandInput, options?: __HttpHandlerOptions): Promise<RegisterContainerInstanceCommandOutput>;
     registerContainerInstance(args: RegisterContainerInstanceCommandInput, cb: (err: any, data?: RegisterContainerInstanceCommandOutput) => void): void;
@@ -565,7 +563,7 @@ export declare class ECS extends ECSClient {
      * 		       <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
+     * 			the IAM policy that's 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
@@ -587,11 +585,11 @@ export declare class ECS extends ECSClient {
      * 				<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>The Amazon ECS API follows an eventual consistency model. This is because 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>
@@ -645,8 +643,7 @@ export declare class ECS extends ECSClient {
      * <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>
+     * 		       <p>Sent to acknowledge that an attachment changed states.</p>
      */
     submitAttachmentStateChanges(args: SubmitAttachmentStateChangesCommandInput, options?: __HttpHandlerOptions): Promise<SubmitAttachmentStateChangesCommandOutput>;
     submitAttachmentStateChanges(args: SubmitAttachmentStateChangesCommandInput, cb: (err: any, data?: SubmitAttachmentStateChangesCommandOutput) => void): void;
@@ -655,8 +652,7 @@ export declare class ECS extends ECSClient {
      * <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>
+     * 		       <p>Sent to acknowledge that a container changed states.</p>
      */
     submitContainerStateChange(args: SubmitContainerStateChangeCommandInput, options?: __HttpHandlerOptions): Promise<SubmitContainerStateChangeCommandOutput>;
     submitContainerStateChange(args: SubmitContainerStateChangeCommandInput, cb: (err: any, data?: SubmitContainerStateChangeCommandOutput) => void): void;
@@ -665,16 +661,15 @@ export declare class ECS extends ECSClient {
      * <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>
+     * 		       <p>Sent to acknowledge that a task changed states.</p>
      */
     submitTaskStateChange(args: SubmitTaskStateChangeCommandInput, options?: __HttpHandlerOptions): Promise<SubmitTaskStateChangeCommandOutput>;
     submitTaskStateChange(args: SubmitTaskStateChangeCommandInput, cb: (err: any, data?: SubmitTaskStateChangeCommandOutput) => void): void;
     submitTaskStateChange(args: SubmitTaskStateChangeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SubmitTaskStateChangeCommandOutput) => void): void;
     /**
      * <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
+     * 				<code>resourceArn</code>. If existing tags on a resource aren't specified in the
+     * 			request parameters, they aren't changed. When a resource is deleted, the tags that are
      * 			associated with that resource are deleted as well.</p>
      */
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
@@ -706,14 +701,14 @@ export declare class ECS extends ECSClient {
     updateClusterSettings(args: UpdateClusterSettingsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateClusterSettingsCommandOutput) => void): void;
     /**
      * <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
+     * 			Amazon ECS container agent doesn't 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
+     * 				you can update the <code>ecs-init</code> package. This updates 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>
@@ -732,7 +727,7 @@ export declare class ECS extends ECSClient {
      * 			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
+     * 			         <p>A container instance can't 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>
@@ -753,14 +748,14 @@ export declare class ECS extends ECSClient {
      * 					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>
+     * 					load balancer are considered healthy if they're 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
+     * 					they're in the <code>RUNNING</code> state and the container instance they're
      * 					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
+     * 					number of running tasks during task replacement. You can use this 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.
@@ -769,7 +764,7 @@ export declare class ECS extends ECSClient {
      * 			         </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>
+     * 			aren't 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
@@ -794,12 +789,12 @@ export declare class ECS extends ECSClient {
      * 			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>
+     * 			deployment is 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>
+     * 			task definition need to be updated, 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>
@@ -809,7 +804,7 @@ export declare class ECS extends ECSClient {
      * 			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
+     * 				definition for your service (for example, <code>my_image:latest</code>), you don't
      * 				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
@@ -825,15 +820,15 @@ export declare class ECS extends ECSClient {
      * 						<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
+     * 					services that don't use a load balancer are considered healthy if they're in the
+     * 						<code>RUNNING</code> state. Tasks for services that use a load balancer are
+     * 					considered healthy if they're in the <code>RUNNING</code> state and the
+     * 					container instance they're 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
+     * 					number of running tasks during a deployment. You can use it 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>
@@ -841,22 +836,22 @@ export declare class ECS extends ECSClient {
      *          </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
+     * 			results in a <code>SIGTERM</code> and a 30-second timeout. After this,
      * 				<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>
+     * 			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>
+     * 					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>
+     * 					Availability Zones in this manner even though you can choose a different
+     * 					placement strategy.</p>
      * 				           <ul>
      *                   <li>
      * 						               <p>Sort the valid container instances by the fewest number of running