@aws-sdk/client-ecs 3.36.0 → 3.39.0

package/CHANGELOG.md

@@ -3,6 +3,51 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.39.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.38.0...v3.39.0) (2021-10-29)
+
+
+### Features
+
+* **clients:** update clients as of 2021/10/28 ([#2955](https://github.com/aws/aws-sdk-js-v3/issues/2955)) ([378d161](https://github.com/aws/aws-sdk-js-v3/commit/378d16166de49b06263291001986715d9533cadf))
+
+
+
+
+
+# [3.38.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.37.0...v3.38.0) (2021-10-22)
+
+
+### Features
+
+* **client-documentation-generator:** rename package ([#2916](https://github.com/aws/aws-sdk-js-v3/issues/2916)) ([1a80bfd](https://github.com/aws/aws-sdk-js-v3/commit/1a80bfd2dfc583001ddb4a21b6432eaaad699aa7))
+* **clients:** export folder from index.ts ([#2912](https://github.com/aws/aws-sdk-js-v3/issues/2912)) ([183b46d](https://github.com/aws/aws-sdk-js-v3/commit/183b46dde7f5613128038bf1c076f3c0b693203b))
+
+
+
+
+
+# [3.37.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.36.1...v3.37.0) (2021-10-15)
+
+
+### Features
+
+* **clients:** update clients as of 10/15/2021 ([#2902](https://github.com/aws/aws-sdk-js-v3/issues/2902)) ([2730b54](https://github.com/aws/aws-sdk-js-v3/commit/2730b5424377944a5a2ad5e1ad7d3ca4135dae1c))
+
+
+
+
+
+## [3.36.1](https://github.com/aws/aws-sdk-js-v3/compare/v3.36.0...v3.36.1) (2021-10-12)
+
+
+### Bug Fixes
+
+* **clients:** emitDeclarationOnly in tsconfig.types.json ([#2893](https://github.com/aws/aws-sdk-js-v3/issues/2893)) ([6dc3d56](https://github.com/aws/aws-sdk-js-v3/commit/6dc3d56c20809c90cbdc4dd48627eeebc64af99d))
+
+
+
+
+
 # [3.36.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.35.0...v3.36.0) (2021-10-08)
 
 

package/dist-cjs/ECS.js

@@ -54,21 +54,6 @@ const UpdateServiceCommand_1 = require("./commands/UpdateServiceCommand");
 const UpdateServicePrimaryTaskSetCommand_1 = require("./commands/UpdateServicePrimaryTaskSetCommand");
 const UpdateTaskSetCommand_1 = require("./commands/UpdateTaskSetCommand");
 const ECSClient_1 = require("./ECSClient");
-/**
- * <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>
- */
 class ECS extends ECSClient_1.ECSClient {
     createCapacityProvider(args, optionsOrCb, cb) {
         const command = new CreateCapacityProviderCommand_1.CreateCapacityProviderCommand(args);

package/dist-cjs/ECSClient.js

@@ -10,21 +10,6 @@ const middleware_signing_1 = require("@aws-sdk/middleware-signing");
 const middleware_user_agent_1 = require("@aws-sdk/middleware-user-agent");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const runtimeConfig_1 = require("./runtimeConfig");
-/**
- * <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>
- */
 class ECSClient extends smithy_client_1.Client {
     constructor(configuration) {
         const _config_0 = runtimeConfig_1.getRuntimeConfig(configuration);
@@ -43,11 +28,6 @@ class ECSClient extends smithy_client_1.Client {
         this.middlewareStack.use(middleware_signing_1.getAwsAuthPlugin(this.config));
         this.middlewareStack.use(middleware_user_agent_1.getUserAgentPlugin(this.config));
     }
-    /**
-     * 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() {
         super.destroy();
     }

package/dist-cjs/commands/CreateCapacityProviderCommand.js

@@ -5,41 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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.
- *
- */
 class CreateCapacityProviderCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/CreateClusterCommand.js

@@ -5,46 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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.
- *
- */
 class CreateClusterCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/CreateServiceCommand.js

@@ -5,140 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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.
- *
- */
 class CreateServiceCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/CreateTaskSetCommand.js

@@ -5,38 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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.
- *
- */
 class CreateTaskSetCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/DeleteAccountSettingCommand.js

@@ -5,36 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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.
- *
- */
 class DeleteAccountSettingCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/DeleteAttributesCommand.js

@@ -5,35 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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.
- *
- */
 class DeleteAttributesCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/DeleteCapacityProviderCommand.js

@@ -5,49 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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.
- *
- */
 class DeleteCapacityProviderCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/DeleteClusterCommand.js

@@ -5,41 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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.
- *
- */
 class DeleteClusterCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/DeleteServiceCommand.js

@@ -5,55 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <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.
- *
- */
 class DeleteServiceCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);

package/dist-cjs/commands/DeleteTaskSetCommand.js

@@ -5,36 +5,11 @@ const middleware_serde_1 = require("@aws-sdk/middleware-serde");
 const smithy_client_1 = require("@aws-sdk/smithy-client");
 const models_0_1 = require("../models/models_0");
 const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
-/**
- * <p>Deletes a specified task set within a service. This is used when a service uses the
- * 				<code>EXTERNAL</code> deployment controller type. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html">Amazon ECS Deployment Types</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ECSClient, DeleteTaskSetCommand } from "@aws-sdk/client-ecs"; // ES Modules import
- * // const { ECSClient, DeleteTaskSetCommand } = require("@aws-sdk/client-ecs"); // CommonJS import
- * const client = new ECSClient(config);
- * const command = new DeleteTaskSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTaskSetCommandInput} for command's `input` shape.
- * @see {@link DeleteTaskSetCommandOutput} for command's `response` shape.
- * @see {@link ECSClientResolvedConfig | config} for command's `input` shape.
- *
- */
 class DeleteTaskSetCommand extends smithy_client_1.Command {
-    // Start section: command_properties
-    // End section: command_properties
     constructor(input) {
-        // Start section: command_constructor
         super();
         this.input = input;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
         const stack = clientStack.concat(this.middlewareStack);