@aws-sdk/client-ecs 3.36.0 → 3.39.0

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

@@ -61,136 +61,59 @@ import { UpdateTaskSetCommandInput, UpdateTaskSetCommandOutput } from "./command
 export declare type ServiceInputTypes = CreateCapacityProviderCommandInput | CreateClusterCommandInput | CreateServiceCommandInput | CreateTaskSetCommandInput | DeleteAccountSettingCommandInput | DeleteAttributesCommandInput | DeleteCapacityProviderCommandInput | DeleteClusterCommandInput | DeleteServiceCommandInput | DeleteTaskSetCommandInput | DeregisterContainerInstanceCommandInput | DeregisterTaskDefinitionCommandInput | DescribeCapacityProvidersCommandInput | DescribeClustersCommandInput | DescribeContainerInstancesCommandInput | DescribeServicesCommandInput | DescribeTaskDefinitionCommandInput | DescribeTaskSetsCommandInput | DescribeTasksCommandInput | DiscoverPollEndpointCommandInput | ExecuteCommandCommandInput | ListAccountSettingsCommandInput | ListAttributesCommandInput | ListClustersCommandInput | ListContainerInstancesCommandInput | ListServicesCommandInput | ListTagsForResourceCommandInput | ListTaskDefinitionFamiliesCommandInput | ListTaskDefinitionsCommandInput | ListTasksCommandInput | PutAccountSettingCommandInput | PutAccountSettingDefaultCommandInput | PutAttributesCommandInput | PutClusterCapacityProvidersCommandInput | RegisterContainerInstanceCommandInput | RegisterTaskDefinitionCommandInput | RunTaskCommandInput | StartTaskCommandInput | StopTaskCommandInput | SubmitAttachmentStateChangesCommandInput | SubmitContainerStateChangeCommandInput | SubmitTaskStateChangeCommandInput | TagResourceCommandInput | UntagResourceCommandInput | UpdateCapacityProviderCommandInput | UpdateClusterCommandInput | UpdateClusterSettingsCommandInput | UpdateContainerAgentCommandInput | UpdateContainerInstancesStateCommandInput | UpdateServiceCommandInput | UpdateServicePrimaryTaskSetCommandInput | UpdateTaskSetCommandInput;
 export declare type ServiceOutputTypes = CreateCapacityProviderCommandOutput | CreateClusterCommandOutput | CreateServiceCommandOutput | CreateTaskSetCommandOutput | DeleteAccountSettingCommandOutput | DeleteAttributesCommandOutput | DeleteCapacityProviderCommandOutput | DeleteClusterCommandOutput | DeleteServiceCommandOutput | DeleteTaskSetCommandOutput | DeregisterContainerInstanceCommandOutput | DeregisterTaskDefinitionCommandOutput | DescribeCapacityProvidersCommandOutput | DescribeClustersCommandOutput | DescribeContainerInstancesCommandOutput | DescribeServicesCommandOutput | DescribeTaskDefinitionCommandOutput | DescribeTaskSetsCommandOutput | DescribeTasksCommandOutput | DiscoverPollEndpointCommandOutput | ExecuteCommandCommandOutput | ListAccountSettingsCommandOutput | ListAttributesCommandOutput | ListClustersCommandOutput | ListContainerInstancesCommandOutput | ListServicesCommandOutput | ListTagsForResourceCommandOutput | ListTaskDefinitionFamiliesCommandOutput | ListTaskDefinitionsCommandOutput | ListTasksCommandOutput | PutAccountSettingCommandOutput | PutAccountSettingDefaultCommandOutput | PutAttributesCommandOutput | PutClusterCapacityProvidersCommandOutput | RegisterContainerInstanceCommandOutput | RegisterTaskDefinitionCommandOutput | RunTaskCommandOutput | StartTaskCommandOutput | StopTaskCommandOutput | SubmitAttachmentStateChangesCommandOutput | SubmitContainerStateChangeCommandOutput | SubmitTaskStateChangeCommandOutput | TagResourceCommandOutput | UntagResourceCommandOutput | UpdateCapacityProviderCommandOutput | UpdateClusterCommandOutput | UpdateClusterSettingsCommandOutput | UpdateContainerAgentCommandOutput | UpdateContainerInstancesStateCommandOutput | UpdateServiceCommandOutput | UpdateServicePrimaryTaskSetCommandOutput | UpdateTaskSetCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type ECSClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of ECSClient class constructor that set the region, credentials and other options.
- */
+
 export interface ECSClientConfig extends ECSClientConfigType {
 }
 declare type ECSClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of ECSClient class. This is resolved and normalized from the {@link ECSClientConfig | constructor configuration interface}.
- */
+
 export interface ECSClientResolvedConfig extends ECSClientResolvedConfigType {
 }
-/**
- * <fullname>Amazon Elastic Container Service</fullname>
- * 		       <p>Amazon Elastic Container Service (Amazon ECS) is a highly scalable, fast, container management service that 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
- * 			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>
- * 		       <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>
- */
+
 export declare class ECSClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, ECSClientResolvedConfig> {
-    /**
-     * The resolved configuration of ECSClient class. This is resolved and normalized from the {@link ECSClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: ECSClientResolvedConfig;
     constructor(configuration: ECSClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

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

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

@@ -6,40 +6,11 @@ export interface CreateClusterCommandInput extends CreateClusterRequest {
 }
 export interface CreateClusterCommandOutput extends CreateClusterResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new Amazon ECS cluster. By default, your account receives a <code>default</code>
- * 			cluster when you launch your first container instance. However, you can create your own
- * 			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
- * 					Service-Linked Roles for Amazon ECS</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, CreateClusterCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, CreateClusterCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new CreateClusterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateClusterCommandInput} for command's `input` shape.
- * @see {@link CreateClusterCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateClusterCommand extends $Command<CreateClusterCommandInput, CreateClusterCommandOutput, ECSClientResolvedConfig> {
     readonly input: CreateClusterCommandInput;
     constructor(input: CreateClusterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateClusterCommandInput, CreateClusterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,134 +6,11 @@ export interface CreateServiceCommandInput extends CreateServiceRequest {
 }
 export interface CreateServiceCommandOutput extends CreateServiceResponse, __MetadataBearer {
 }
-/**
- * <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>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>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
- * 					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
- * 						<i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * 			         </li>
- *             <li>
- * 				           <p>
- *                   <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
- * 					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
- * 			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
- * 			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>
- * 			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>
- * 		       <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>
- * 		       <p>When the service scheduler launches new tasks, it determines task placement in your
- * 			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>
- * 			         </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>
- * 				           <ul>
- *                   <li>
- * 						               <p>Sort the valid container instances, giving priority to instances that
- * 							have the fewest number of running tasks for this service in their
- * 							respective Availability Zone. 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, CreateServiceCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, CreateServiceCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new CreateServiceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateServiceCommandInput} for command's `input` shape.
- * @see {@link CreateServiceCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateServiceCommand extends $Command<CreateServiceCommandInput, CreateServiceCommandOutput, ECSClientResolvedConfig> {
     readonly input: CreateServiceCommandInput;
     constructor(input: CreateServiceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateServiceCommandInput, CreateServiceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,43 +6,11 @@ export interface DeleteCapacityProviderCommandInput extends DeleteCapacityProvid
 }
 export interface DeleteCapacityProviderCommandOutput extends DeleteCapacityProviderResponse, __MetadataBearer {
 }
-/**
- * <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
- * 				cluster.</p>
- * 		       </note>
- * 		       <p>Prior to a capacity provider being deleted, the capacity provider must be removed from
- * 			the capacity provider strategy from all services. The <a>UpdateService</a>
- * 			API can be used to remove a capacity provider from a service's capacity provider
- * 			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
- * 			a capacity provider from a cluster, you can either use <a>PutClusterCapacityProviders</a> or delete the cluster.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DeleteCapacityProviderCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DeleteCapacityProviderCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DeleteCapacityProviderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteCapacityProviderCommandInput} for command's `input` shape.
- * @see {@link DeleteCapacityProviderCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteCapacityProviderCommand extends $Command<DeleteCapacityProviderCommandInput, DeleteCapacityProviderCommandOutput, ECSClientResolvedConfig> {
     readonly input: DeleteCapacityProviderCommandInput;
     constructor(input: DeleteCapacityProviderCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCapacityProviderCommandInput, DeleteCapacityProviderCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,49 +6,11 @@ export interface DeleteServiceCommandInput extends DeleteServiceRequest {
 }
 export interface DeleteServiceCommandOutput extends DeleteServiceResponse, __MetadataBearer {
 }
-/**
- * <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
- * 			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,
- * 				the service status moves from <code>ACTIVE</code> to <code>DRAINING</code>, and the
- * 				service is no longer visible in the console or in the <a>ListServices</a>
- * 				API operation. After all tasks have transitioned to either <code>STOPPING</code> or
- * 					<code>STOPPED</code> status, the service status moves from <code>DRAINING</code>
- * 				to <code>INACTIVE</code>. Services in the <code>DRAINING</code> or
- * 					<code>INACTIVE</code> status can still be viewed with the <a>DescribeServices</a> API operation. However, in the future,
- * 					<code>INACTIVE</code> services may be cleaned up and purged from Amazon ECS record
- * 				keeping, and <a>DescribeServices</a> calls on those services return a
- * 					<code>ServiceNotFoundException</code> error.</p>
- * 		       </note>
- * 		       <important>
- * 			         <p>If you attempt to create a new service with the same name as an existing service
- * 				in either <code>ACTIVE</code> or <code>DRAINING</code> status, you receive an
- * 				error.</p>
- * 		       </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DeleteServiceCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DeleteServiceCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DeleteServiceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteServiceCommandInput} for command's `input` shape.
- * @see {@link DeleteServiceCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteServiceCommand extends $Command<DeleteServiceCommandInput, DeleteServiceCommandOutput, ECSClientResolvedConfig> {
     readonly input: DeleteServiceCommandInput;
     constructor(input: DeleteServiceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ECSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteServiceCommandInput, DeleteServiceCommandOutput>;
     private serialize;
     private deserialize;