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

package/dist-cjs/commands/GetPredictiveScalingForecastCommand.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPredictiveScalingForecastCommand = 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>Retrieves the forecast data for a predictive scaling policy.</p>
+ *         <p>Load forecasts are predictions of the hourly load values using historical load data
+ *             from CloudWatch and an analysis of historical trends. Capacity forecasts are represented as
+ *             predicted values for the minimum capacity that is needed on an hourly basis, based on
+ *             the hourly load forecast.</p>
+ *         <p>A minimum of 24 hours of data is required to create the initial forecasts. However,
+ *             having a full 14 days of historical data results in more accurate forecasts.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-predictive-scaling.html">Predictive
+ *                 scaling for 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, GetPredictiveScalingForecastCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, GetPredictiveScalingForecastCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new GetPredictiveScalingForecastCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetPredictiveScalingForecastCommandInput} for command's `input` shape.
+ * @see {@link GetPredictiveScalingForecastCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class GetPredictiveScalingForecastCommand 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 = "GetPredictiveScalingForecastCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.GetPredictiveScalingForecastType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.GetPredictiveScalingForecastAnswer.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryGetPredictiveScalingForecastCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryGetPredictiveScalingForecastCommand(output, context);
+    }
+}
+exports.GetPredictiveScalingForecastCommand = GetPredictiveScalingForecastCommand;

package/dist-cjs/commands/PutLifecycleHookCommand.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PutLifecycleHookCommand = 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 a lifecycle hook for the specified Auto Scaling group.</p>
+ *         <p>A lifecycle hook tells Amazon EC2 Auto Scaling to perform an action on an instance when the instance
+ *             launches (before it is put into service) or as the instance terminates (before it is
+ *             fully terminated).</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>
+ *                     <b>Create the lifecycle hook. Specify whether the hook is
+ *                         used when the instances launch or terminate.</b>
+ *                 </p>
+ *             </li>
+ *             <li>
+ *                 <p>If you need more time, record the lifecycle action heartbeat to keep the
+ *                     instance in a pending state using the <a>RecordLifecycleActionHeartbeat</a> API call.</p>
+ *             </li>
+ *             <li>
+ *                 <p>If you finish before the timeout period ends, complete the lifecycle action
+ *                     using the <a>CompleteLifecycleAction</a> API call.</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>
+ *         <p>If you exceed your maximum limit of lifecycle hooks, which by default is 50 per Auto Scaling
+ *             group, the call fails.</p>
+ *         <p>You can view the lifecycle hooks for an Auto Scaling group using the <a>DescribeLifecycleHooks</a> API call. If you are no longer using a lifecycle
+ *             hook, you can delete it by calling the <a>DeleteLifecycleHook</a> API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, PutLifecycleHookCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, PutLifecycleHookCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new PutLifecycleHookCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutLifecycleHookCommandInput} for command's `input` shape.
+ * @see {@link PutLifecycleHookCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class PutLifecycleHookCommand 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 = "PutLifecycleHookCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.PutLifecycleHookType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.PutLifecycleHookAnswer.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryPutLifecycleHookCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryPutLifecycleHookCommand(output, context);
+    }
+}
+exports.PutLifecycleHookCommand = PutLifecycleHookCommand;

package/dist-cjs/commands/PutNotificationConfigurationCommand.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PutNotificationConfigurationCommand = 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>Configures an Auto Scaling group to send notifications when specified events take place.
+ *             Subscribers to the specified topic can have messages delivered to an endpoint such as a
+ *             web server or an email address.</p>
+ *         <p>This configuration overwrites any existing configuration.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ASGettingNotifications.html">Getting Amazon SNS
+ *                 notifications when your Auto Scaling group scales</a> in the
+ *                 <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ *         <p>If you exceed your maximum limit of SNS topics, which is 10 per Auto Scaling group, the call
+ *             fails.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, PutNotificationConfigurationCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, PutNotificationConfigurationCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new PutNotificationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutNotificationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link PutNotificationConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class PutNotificationConfigurationCommand 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 = "PutNotificationConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.PutNotificationConfigurationType.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_queryPutNotificationConfigurationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryPutNotificationConfigurationCommand(output, context);
+    }
+}
+exports.PutNotificationConfigurationCommand = PutNotificationConfigurationCommand;

package/dist-cjs/commands/PutScalingPolicyCommand.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PutScalingPolicyCommand = 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 a scaling policy for an Auto Scaling group. Scaling policies are used to
+ *             scale an Auto Scaling group based on configurable metrics. If no policies are defined, the
+ *             dynamic scaling and predictive scaling features are not used. </p>
+ *         <p>For more information about using dynamic scaling, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scaling-target-tracking.html">Target tracking
+ *                 scaling policies</a> and <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scaling-simple-step.html">Step and simple scaling
+ *                 policies</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ *         <p>For more information about using predictive scaling, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-predictive-scaling.html">Predictive
+ *                 scaling for Amazon EC2 Auto Scaling</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ *         <p>You can view the scaling policies for an Auto Scaling group using the <a>DescribePolicies</a> API call. If you are no longer using a scaling policy,
+ *             you can delete it by calling the <a>DeletePolicy</a> API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, PutScalingPolicyCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, PutScalingPolicyCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new PutScalingPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutScalingPolicyCommandInput} for command's `input` shape.
+ * @see {@link PutScalingPolicyCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class PutScalingPolicyCommand 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 = "PutScalingPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.PutScalingPolicyType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.PolicyARNType.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryPutScalingPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryPutScalingPolicyCommand(output, context);
+    }
+}
+exports.PutScalingPolicyCommand = PutScalingPolicyCommand;

package/dist-cjs/commands/PutScheduledUpdateGroupActionCommand.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PutScheduledUpdateGroupActionCommand = 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 a scheduled scaling action for an Auto Scaling group.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/schedule_time.html">Scheduled scaling</a> in the
+ *                 <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ *         <p>You can view the scheduled actions for an Auto Scaling group using the <a>DescribeScheduledActions</a> API call. If you are no longer using a
+ *             scheduled action, you can delete it by calling the <a>DeleteScheduledAction</a> API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, PutScheduledUpdateGroupActionCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, PutScheduledUpdateGroupActionCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new PutScheduledUpdateGroupActionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutScheduledUpdateGroupActionCommandInput} for command's `input` shape.
+ * @see {@link PutScheduledUpdateGroupActionCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class PutScheduledUpdateGroupActionCommand 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 = "PutScheduledUpdateGroupActionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.PutScheduledUpdateGroupActionType.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_queryPutScheduledUpdateGroupActionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryPutScheduledUpdateGroupActionCommand(output, context);
+    }
+}
+exports.PutScheduledUpdateGroupActionCommand = PutScheduledUpdateGroupActionCommand;

package/dist-cjs/commands/PutWarmPoolCommand.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PutWarmPoolCommand = 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 a warm pool for the specified Auto Scaling group. A warm pool is a pool of
+ *             pre-initialized EC2 instances that sits alongside the Auto Scaling group. Whenever your
+ *             application needs to scale out, the Auto Scaling group can draw on the warm pool to meet its new
+ *             desired capacity. For more information and example configurations, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-warm-pools.html">Warm pools for
+ *                 Amazon EC2 Auto Scaling</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ *         <p>This operation must be called from the Region in which the Auto Scaling group was created.
+ *             This operation cannot be called on an Auto Scaling group that has a mixed instances policy or a
+ *             launch template or launch configuration that requests Spot Instances.</p>
+ *         <p>You can view the instances in the warm pool using the <a>DescribeWarmPool</a> API call. If you are no longer using a warm pool, you can delete it by calling the
+ *                 <a>DeleteWarmPool</a> API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, PutWarmPoolCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, PutWarmPoolCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new PutWarmPoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutWarmPoolCommandInput} for command's `input` shape.
+ * @see {@link PutWarmPoolCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class PutWarmPoolCommand 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 = "PutWarmPoolCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.PutWarmPoolType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.PutWarmPoolAnswer.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryPutWarmPoolCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryPutWarmPoolCommand(output, context);
+    }
+}
+exports.PutWarmPoolCommand = PutWarmPoolCommand;

package/dist-cjs/commands/RecordLifecycleActionHeartbeatCommand.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordLifecycleActionHeartbeatCommand = 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>Records a heartbeat for the lifecycle action associated with the specified token or
+ *             instance. This extends the timeout by the length of time defined using the <a>PutLifecycleHook</a> API call.</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>
+ *                     <b>If you need more time, record the lifecycle action
+ *                         heartbeat to keep the instance in a pending state.</b>
+ *                 </p>
+ *             </li>
+ *             <li>
+ *                 <p>If you finish before the timeout period ends, complete the lifecycle
+ *                     action.</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, RecordLifecycleActionHeartbeatCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, RecordLifecycleActionHeartbeatCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new RecordLifecycleActionHeartbeatCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RecordLifecycleActionHeartbeatCommandInput} for command's `input` shape.
+ * @see {@link RecordLifecycleActionHeartbeatCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class RecordLifecycleActionHeartbeatCommand 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 = "RecordLifecycleActionHeartbeatCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.RecordLifecycleActionHeartbeatType.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.RecordLifecycleActionHeartbeatAnswer.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryRecordLifecycleActionHeartbeatCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryRecordLifecycleActionHeartbeatCommand(output, context);
+    }
+}
+exports.RecordLifecycleActionHeartbeatCommand = RecordLifecycleActionHeartbeatCommand;

package/dist-cjs/commands/ResumeProcessesCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResumeProcessesCommand = 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>Resumes the specified suspended auto scaling processes, or all suspended process, for
+ *             the specified Auto Scaling group.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-suspend-resume-processes.html">Suspending and
+ *                 resuming scaling processes</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, ResumeProcessesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, ResumeProcessesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new ResumeProcessesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResumeProcessesCommandInput} for command's `input` shape.
+ * @see {@link ResumeProcessesCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class ResumeProcessesCommand 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 = "ResumeProcessesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.ScalingProcessQuery.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_queryResumeProcessesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryResumeProcessesCommand(output, context);
+    }
+}
+exports.ResumeProcessesCommand = ResumeProcessesCommand;