@aws-sdk/client-auto-scaling 3.32.0 → 3.36.0

package/dist-cjs/AutoScalingClient.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoScalingClient = void 0;
+const config_resolver_1 = require("@aws-sdk/config-resolver");
+const middleware_content_length_1 = require("@aws-sdk/middleware-content-length");
+const middleware_host_header_1 = require("@aws-sdk/middleware-host-header");
+const middleware_logger_1 = require("@aws-sdk/middleware-logger");
+const middleware_retry_1 = require("@aws-sdk/middleware-retry");
+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 EC2 Auto Scaling</fullname>
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *         <p>Amazon EC2 Auto Scaling is designed to automatically launch or terminate EC2 instances
+ *             based on user-defined scaling policies, scheduled actions, and health checks.</p>
+ *         <p>For more information about Amazon EC2 Auto Scaling, see the <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/what-is-amazon-ec2-auto-scaling.html">Amazon EC2 Auto Scaling User Guide</a>. For information about granting IAM users required
+ *             permissions for calls to Amazon EC2 Auto Scaling, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/APIReference/ec2-auto-scaling-api-permissions.html">Granting
+ *                 IAM users required permissions for Amazon EC2 Auto Scaling resources</a> in the
+ *                 <i>Amazon EC2 Auto Scaling API Reference</i>.</p>
+ */
+class AutoScalingClient extends smithy_client_1.Client {
+    constructor(configuration) {
+        const _config_0 = runtimeConfig_1.getRuntimeConfig(configuration);
+        const _config_1 = config_resolver_1.resolveRegionConfig(_config_0);
+        const _config_2 = config_resolver_1.resolveEndpointsConfig(_config_1);
+        const _config_3 = middleware_retry_1.resolveRetryConfig(_config_2);
+        const _config_4 = middleware_host_header_1.resolveHostHeaderConfig(_config_3);
+        const _config_5 = middleware_signing_1.resolveAwsAuthConfig(_config_4);
+        const _config_6 = middleware_user_agent_1.resolveUserAgentConfig(_config_5);
+        super(_config_6);
+        this.config = _config_6;
+        this.middlewareStack.use(middleware_retry_1.getRetryPlugin(this.config));
+        this.middlewareStack.use(middleware_content_length_1.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middleware_host_header_1.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middleware_logger_1.getLoggerPlugin(this.config));
+        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();
+    }
+}
+exports.AutoScalingClient = AutoScalingClient;

package/dist-cjs/commands/AttachInstancesCommand.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachInstancesCommand = void 0;
+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_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Attaches one or more EC2 instances to the specified Auto Scaling group.</p>
+ *         <p>When you attach instances, Amazon EC2 Auto Scaling increases the desired capacity of the group by the
+ *             number of instances being attached. If the number of instances being attached plus the
+ *             desired capacity of the group exceeds the maximum size of the group, the operation
+ *             fails.</p>
+ *         <p>If there is a Classic Load Balancer attached to your Auto Scaling group, the instances are
+ *             also registered with the load balancer. If there are target groups attached to your Auto Scaling
+ *             group, the instances are also registered with the target groups.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/attach-instance-asg.html">Attach EC2 instances to
+ *                 your Auto Scaling group</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, AttachInstancesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, AttachInstancesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new AttachInstancesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AttachInstancesCommandInput} for command's `input` shape.
+ * @see {@link AttachInstancesCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class AttachInstancesCommand 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);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "AttachInstancesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.AttachInstancesQuery.filterSensitiveLog,
+            outputFilterSensitiveLog: (output) => output,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryAttachInstancesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryAttachInstancesCommand(output, context);
+    }
+}
+exports.AttachInstancesCommand = AttachInstancesCommand;

package/dist-cjs/commands/AttachLoadBalancerTargetGroupsCommand.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachLoadBalancerTargetGroupsCommand = void 0;
+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_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Attaches one or more target groups to the specified Auto Scaling group.</p>
+ *         <p>This operation is used with the following load balancer types: </p>
+ *         <ul>
+ *             <li>
+ *                 <p> Application Load Balancer - Operates at the application layer (layer 7) and
+ *                     supports HTTP and HTTPS. </p>
+ *             </li>
+ *             <li>
+ *                 <p> Network Load Balancer - Operates at the transport layer (layer 4) and
+ *                     supports TCP, TLS, and UDP. </p>
+ *             </li>
+ *             <li>
+ *                 <p> Gateway Load Balancer - Operates at the network layer (layer 3).</p>
+ *             </li>
+ *          </ul>
+ *         <p>To describe the target groups for an Auto Scaling group, call the <a>DescribeLoadBalancerTargetGroups</a> API. To detach the target group from
+ *             the Auto Scaling group, call the <a>DetachLoadBalancerTargetGroups</a> API.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/autoscaling-load-balancer.html">Elastic Load Balancing and
+ *                 Amazon EC2 Auto Scaling</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, AttachLoadBalancerTargetGroupsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, AttachLoadBalancerTargetGroupsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new AttachLoadBalancerTargetGroupsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AttachLoadBalancerTargetGroupsCommandInput} for command's `input` shape.
+ * @see {@link AttachLoadBalancerTargetGroupsCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class AttachLoadBalancerTargetGroupsCommand 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);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "AttachLoadBalancerTargetGroupsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.AttachLoadBalancerTargetGroupsType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.AttachLoadBalancerTargetGroupsResultType.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryAttachLoadBalancerTargetGroupsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryAttachLoadBalancerTargetGroupsCommand(output, context);
+    }
+}
+exports.AttachLoadBalancerTargetGroupsCommand = AttachLoadBalancerTargetGroupsCommand;

package/dist-cjs/commands/AttachLoadBalancersCommand.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachLoadBalancersCommand = void 0;
+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_query_1 = require("../protocols/Aws_query");
+/**
+ * <note>
+ *             <p>To attach an Application Load Balancer, Network Load Balancer, or Gateway Load
+ *                 Balancer, use the <a>AttachLoadBalancerTargetGroups</a> API operation
+ *                 instead.</p>
+ *         </note>
+ *         <p>Attaches one or more Classic Load Balancers to the specified Auto Scaling group. Amazon EC2 Auto Scaling
+ *             registers the running instances with these Classic Load Balancers.</p>
+ *         <p>To describe the load balancers for an Auto Scaling group, call the <a>DescribeLoadBalancers</a> API. To detach the load balancer from the Auto Scaling
+ *             group, call the <a>DetachLoadBalancers</a> API.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/autoscaling-load-balancer.html">Elastic Load Balancing and
+ *                 Amazon EC2 Auto Scaling</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, AttachLoadBalancersCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, AttachLoadBalancersCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new AttachLoadBalancersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AttachLoadBalancersCommandInput} for command's `input` shape.
+ * @see {@link AttachLoadBalancersCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class AttachLoadBalancersCommand 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);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "AttachLoadBalancersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.AttachLoadBalancersType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.AttachLoadBalancersResultType.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryAttachLoadBalancersCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryAttachLoadBalancersCommand(output, context);
+    }
+}
+exports.AttachLoadBalancersCommand = AttachLoadBalancersCommand;

package/dist-cjs/commands/BatchDeleteScheduledActionCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchDeleteScheduledActionCommand = void 0;
+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_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Deletes one or more scheduled actions for the specified Auto Scaling group.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, BatchDeleteScheduledActionCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, BatchDeleteScheduledActionCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new BatchDeleteScheduledActionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BatchDeleteScheduledActionCommandInput} for command's `input` shape.
+ * @see {@link BatchDeleteScheduledActionCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class BatchDeleteScheduledActionCommand 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);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "BatchDeleteScheduledActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.BatchDeleteScheduledActionType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.BatchDeleteScheduledActionAnswer.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryBatchDeleteScheduledActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryBatchDeleteScheduledActionCommand(output, context);
+    }
+}
+exports.BatchDeleteScheduledActionCommand = BatchDeleteScheduledActionCommand;

package/dist-cjs/commands/BatchPutScheduledUpdateGroupActionCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchPutScheduledUpdateGroupActionCommand = void 0;
+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_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Creates or updates one or more scheduled scaling actions for an Auto Scaling group.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, BatchPutScheduledUpdateGroupActionCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, BatchPutScheduledUpdateGroupActionCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new BatchPutScheduledUpdateGroupActionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link BatchPutScheduledUpdateGroupActionCommandInput} for command's `input` shape.
+ * @see {@link BatchPutScheduledUpdateGroupActionCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class BatchPutScheduledUpdateGroupActionCommand 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);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "BatchPutScheduledUpdateGroupActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.BatchPutScheduledUpdateGroupActionType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.BatchPutScheduledUpdateGroupActionAnswer.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryBatchPutScheduledUpdateGroupActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryBatchPutScheduledUpdateGroupActionCommand(output, context);
+    }
+}
+exports.BatchPutScheduledUpdateGroupActionCommand = BatchPutScheduledUpdateGroupActionCommand;

package/dist-cjs/commands/CancelInstanceRefreshCommand.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelInstanceRefreshCommand = void 0;
+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_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Cancels an instance refresh operation in progress. Cancellation does not roll back any
+ *             replacements that have already been completed, but it prevents new replacements from
+ *             being started. </p>
+ *         <p>This operation is part of the <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-instance-refresh.html">instance refresh
+ *                 feature</a> in Amazon EC2 Auto Scaling, which helps you update instances in your Auto Scaling group
+ *             after you make configuration changes.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, CancelInstanceRefreshCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, CancelInstanceRefreshCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new CancelInstanceRefreshCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CancelInstanceRefreshCommandInput} for command's `input` shape.
+ * @see {@link CancelInstanceRefreshCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CancelInstanceRefreshCommand 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);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "CancelInstanceRefreshCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CancelInstanceRefreshType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CancelInstanceRefreshAnswer.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryCancelInstanceRefreshCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryCancelInstanceRefreshCommand(output, context);
+    }
+}
+exports.CancelInstanceRefreshCommand = CancelInstanceRefreshCommand;

package/dist-cjs/commands/CompleteLifecycleActionCommand.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompleteLifecycleActionCommand = void 0;
+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_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Completes the lifecycle action for the specified token or instance with the specified
+ *             result.</p>
+ *         <p>This step is a part of the procedure for adding a lifecycle hook to an Auto Scaling
+ *             group:</p>
+ *         <ol>
+ *             <li>
+ *                 <p>(Optional) Create a Lambda function and a rule that allows CloudWatch Events to
+ *                     invoke your Lambda function when Amazon EC2 Auto Scaling launches or terminates
+ *                     instances.</p>
+ *             </li>
+ *             <li>
+ *                 <p>(Optional) Create a notification target and an IAM role. The target can be
+ *                     either an Amazon SQS queue or an Amazon SNS topic. The role allows Amazon EC2 Auto Scaling to
+ *                     publish lifecycle notifications to the target.</p>
+ *             </li>
+ *             <li>
+ *                 <p>Create the lifecycle hook. Specify whether the hook is used when the instances
+ *                     launch or terminate.</p>
+ *             </li>
+ *             <li>
+ *                 <p>If you need more time, record the lifecycle action heartbeat to keep the
+ *                     instance in a pending state.</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                     <b>If you finish before the timeout period ends, complete the
+ *                         lifecycle action.</b>
+ *                 </p>
+ *             </li>
+ *          </ol>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/lifecycle-hooks.html">Amazon EC2 Auto Scaling lifecycle
+ *                 hooks</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, CompleteLifecycleActionCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, CompleteLifecycleActionCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new CompleteLifecycleActionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CompleteLifecycleActionCommandInput} for command's `input` shape.
+ * @see {@link CompleteLifecycleActionCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CompleteLifecycleActionCommand 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);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "CompleteLifecycleActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CompleteLifecycleActionType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CompleteLifecycleActionAnswer.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryCompleteLifecycleActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryCompleteLifecycleActionCommand(output, context);
+    }
+}
+exports.CompleteLifecycleActionCommand = CompleteLifecycleActionCommand;

package/dist-cjs/commands/CreateAutoScalingGroupCommand.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAutoScalingGroupCommand = void 0;
+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_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>
+ *             <b>We strongly recommend using a launch template when calling this operation to ensure full functionality for Amazon EC2 Auto Scaling and Amazon EC2.</b>
+ *          </p>
+ *          <p>Creates an Auto Scaling group with
+ *             the specified name and attributes. </p>
+ *         <p>If you exceed your maximum limit of Auto Scaling groups, the call fails. To query this limit,
+ *             call the <a>DescribeAccountLimits</a> API. For information about updating
+ *             this limit, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-account-limits.html">Amazon EC2 Auto Scaling service
+ *                 quotas</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ *         <p>For introductory exercises for creating an Auto Scaling group, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/GettingStartedTutorial.html">Getting started with
+ *                 Amazon EC2 Auto Scaling</a> and <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-register-lbs-with-asg.html">Tutorial: Set up a
+ *                 scaled and load-balanced application</a> in the
+ *                 <i>Amazon EC2 Auto Scaling User Guide</i>. For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/AutoScalingGroup.html">Auto Scaling
+ *                 groups</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ *         <p>Every Auto Scaling group has three size parameters (<code>DesiredCapacity</code>,
+ *                 <code>MaxSize</code>, and <code>MinSize</code>). Usually, you set these sizes based
+ *             on a specific number of instances. However, if you configure a mixed instances policy
+ *             that defines weights for the instance types, you must specify these sizes with the same
+ *             units that you use for weighting instances.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, CreateAutoScalingGroupCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, CreateAutoScalingGroupCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new CreateAutoScalingGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateAutoScalingGroupCommandInput} for command's `input` shape.
+ * @see {@link CreateAutoScalingGroupCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateAutoScalingGroupCommand 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);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "CreateAutoScalingGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateAutoScalingGroupType.filterSensitiveLog,
+            outputFilterSensitiveLog: (output) => output,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryCreateAutoScalingGroupCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryCreateAutoScalingGroupCommand(output, context);
+    }
+}
+exports.CreateAutoScalingGroupCommand = CreateAutoScalingGroupCommand;