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

package/dist-types/commands/DescribeWarmPoolCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { DescribeWarmPoolAnswer, DescribeWarmPoolType } from "../models/models_0";
+export interface DescribeWarmPoolCommandInput extends DescribeWarmPoolType {
+}
+export interface DescribeWarmPoolCommandOutput extends DescribeWarmPoolAnswer, __MetadataBearer {
+}
+/**
+ * <p>Gets information about a warm pool and its instances.</p>
+ *         <p>For more information, 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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, DescribeWarmPoolCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, DescribeWarmPoolCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new DescribeWarmPoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeWarmPoolCommandInput} for command's `input` shape.
+ * @see {@link DescribeWarmPoolCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeWarmPoolCommand extends $Command<DescribeWarmPoolCommandInput, DescribeWarmPoolCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: DescribeWarmPoolCommandInput;
+    constructor(input: DescribeWarmPoolCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeWarmPoolCommandInput, DescribeWarmPoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DetachInstancesCommand.d.ts

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { DetachInstancesAnswer, DetachInstancesQuery } from "../models/models_0";
+export interface DetachInstancesCommandInput extends DetachInstancesQuery {
+}
+export interface DetachInstancesCommandOutput extends DetachInstancesAnswer, __MetadataBearer {
+}
+/**
+ * <p>Removes one or more instances from the specified Auto Scaling group.</p>
+ *         <p>After the instances are detached, you can manage them independent of the Auto Scaling
+ *             group.</p>
+ *         <p>If you do not specify the option to decrement the desired capacity, Amazon EC2 Auto Scaling launches
+ *             instances to replace the ones that are detached.</p>
+ *         <p>If there is a Classic Load Balancer attached to the Auto Scaling group, the instances are
+ *             deregistered from the load balancer. If there are target groups attached to the Auto Scaling
+ *             group, the instances are deregistered from the target groups.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/detach-instance-asg.html">Detach EC2 instances from
+ *                 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, DetachInstancesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, DetachInstancesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new DetachInstancesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetachInstancesCommandInput} for command's `input` shape.
+ * @see {@link DetachInstancesCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetachInstancesCommand extends $Command<DetachInstancesCommandInput, DetachInstancesCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: DetachInstancesCommandInput;
+    constructor(input: DetachInstancesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachInstancesCommandInput, DetachInstancesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DetachLoadBalancerTargetGroupsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { DetachLoadBalancerTargetGroupsResultType, DetachLoadBalancerTargetGroupsType } from "../models/models_0";
+export interface DetachLoadBalancerTargetGroupsCommandInput extends DetachLoadBalancerTargetGroupsType {
+}
+export interface DetachLoadBalancerTargetGroupsCommandOutput extends DetachLoadBalancerTargetGroupsResultType, __MetadataBearer {
+}
+/**
+ * <p>Detaches one or more target groups from 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, DetachLoadBalancerTargetGroupsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, DetachLoadBalancerTargetGroupsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new DetachLoadBalancerTargetGroupsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetachLoadBalancerTargetGroupsCommandInput} for command's `input` shape.
+ * @see {@link DetachLoadBalancerTargetGroupsCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetachLoadBalancerTargetGroupsCommand extends $Command<DetachLoadBalancerTargetGroupsCommandInput, DetachLoadBalancerTargetGroupsCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: DetachLoadBalancerTargetGroupsCommandInput;
+    constructor(input: DetachLoadBalancerTargetGroupsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachLoadBalancerTargetGroupsCommandInput, DetachLoadBalancerTargetGroupsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DetachLoadBalancersCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { DetachLoadBalancersResultType, DetachLoadBalancersType } from "../models/models_0";
+export interface DetachLoadBalancersCommandInput extends DetachLoadBalancersType {
+}
+export interface DetachLoadBalancersCommandOutput extends DetachLoadBalancersResultType, __MetadataBearer {
+}
+/**
+ * <p>Detaches one or more Classic Load Balancers from the specified Auto Scaling group.</p>
+ *         <p>This operation detaches only Classic Load Balancers. If you have Application Load
+ *             Balancers, Network Load Balancers, or Gateway Load Balancers, use the <a>DetachLoadBalancerTargetGroups</a> API instead.</p>
+ *         <p>When you detach a load balancer, it enters the <code>Removing</code> state while
+ *             deregistering the instances in the group. When all instances are deregistered, then you
+ *             can no longer describe the load balancer using the <a>DescribeLoadBalancers</a> API call. The instances remain running.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, DetachLoadBalancersCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, DetachLoadBalancersCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new DetachLoadBalancersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetachLoadBalancersCommandInput} for command's `input` shape.
+ * @see {@link DetachLoadBalancersCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetachLoadBalancersCommand extends $Command<DetachLoadBalancersCommandInput, DetachLoadBalancersCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: DetachLoadBalancersCommandInput;
+    constructor(input: DetachLoadBalancersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetachLoadBalancersCommandInput, DetachLoadBalancersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DisableMetricsCollectionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { DisableMetricsCollectionQuery } from "../models/models_0";
+export interface DisableMetricsCollectionCommandInput extends DisableMetricsCollectionQuery {
+}
+export interface DisableMetricsCollectionCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Disables group metrics 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, DisableMetricsCollectionCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, DisableMetricsCollectionCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new DisableMetricsCollectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisableMetricsCollectionCommandInput} for command's `input` shape.
+ * @see {@link DisableMetricsCollectionCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DisableMetricsCollectionCommand extends $Command<DisableMetricsCollectionCommandInput, DisableMetricsCollectionCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: DisableMetricsCollectionCommandInput;
+    constructor(input: DisableMetricsCollectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableMetricsCollectionCommandInput, DisableMetricsCollectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/EnableMetricsCollectionCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { EnableMetricsCollectionQuery } from "../models/models_0";
+export interface EnableMetricsCollectionCommandInput extends EnableMetricsCollectionQuery {
+}
+export interface EnableMetricsCollectionCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Enables group metrics for the specified Auto Scaling group. For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-monitoring.html">Monitoring CloudWatch metrics for your Auto Scaling groups and instances</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, EnableMetricsCollectionCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, EnableMetricsCollectionCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new EnableMetricsCollectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnableMetricsCollectionCommandInput} for command's `input` shape.
+ * @see {@link EnableMetricsCollectionCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class EnableMetricsCollectionCommand extends $Command<EnableMetricsCollectionCommandInput, EnableMetricsCollectionCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: EnableMetricsCollectionCommandInput;
+    constructor(input: EnableMetricsCollectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableMetricsCollectionCommandInput, EnableMetricsCollectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/EnterStandbyCommand.d.ts

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { EnterStandbyAnswer, EnterStandbyQuery } from "../models/models_0";
+export interface EnterStandbyCommandInput extends EnterStandbyQuery {
+}
+export interface EnterStandbyCommandOutput extends EnterStandbyAnswer, __MetadataBearer {
+}
+/**
+ * <p>Moves the specified instances into the standby state.</p>
+ *         <p>If you choose to decrement the desired capacity of the Auto Scaling group, the instances can
+ *             enter standby as long as the desired capacity of the Auto Scaling group after the instances are
+ *             placed into standby is equal to or greater than the minimum capacity of the
+ *             group.</p>
+ *         <p>If you choose not to decrement the desired capacity of the Auto Scaling group, the Auto Scaling group
+ *             launches new instances to replace the instances on standby.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-enter-exit-standby.html">Temporarily removing
+ *                 instances from 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, EnterStandbyCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, EnterStandbyCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new EnterStandbyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnterStandbyCommandInput} for command's `input` shape.
+ * @see {@link EnterStandbyCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class EnterStandbyCommand extends $Command<EnterStandbyCommandInput, EnterStandbyCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: EnterStandbyCommandInput;
+    constructor(input: EnterStandbyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnterStandbyCommandInput, EnterStandbyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ExecutePolicyCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { ExecutePolicyType } from "../models/models_0";
+export interface ExecutePolicyCommandInput extends ExecutePolicyType {
+}
+export interface ExecutePolicyCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Executes the specified policy. This can be useful for testing the design of your
+ *             scaling policy.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, ExecutePolicyCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, ExecutePolicyCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new ExecutePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExecutePolicyCommandInput} for command's `input` shape.
+ * @see {@link ExecutePolicyCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ExecutePolicyCommand extends $Command<ExecutePolicyCommandInput, ExecutePolicyCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: ExecutePolicyCommandInput;
+    constructor(input: ExecutePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecutePolicyCommandInput, ExecutePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ExitStandbyCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { ExitStandbyAnswer, ExitStandbyQuery } from "../models/models_0";
+export interface ExitStandbyCommandInput extends ExitStandbyQuery {
+}
+export interface ExitStandbyCommandOutput extends ExitStandbyAnswer, __MetadataBearer {
+}
+/**
+ * <p>Moves the specified instances out of the standby state.</p>
+ *         <p>After you put the instances back in service, the desired capacity is
+ *             incremented.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-enter-exit-standby.html">Temporarily removing
+ *                 instances from 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, ExitStandbyCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, ExitStandbyCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new ExitStandbyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExitStandbyCommandInput} for command's `input` shape.
+ * @see {@link ExitStandbyCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ExitStandbyCommand extends $Command<ExitStandbyCommandInput, ExitStandbyCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: ExitStandbyCommandInput;
+    constructor(input: ExitStandbyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExitStandbyCommandInput, ExitStandbyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetPredictiveScalingForecastCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { GetPredictiveScalingForecastAnswer, GetPredictiveScalingForecastType } from "../models/models_0";
+export interface GetPredictiveScalingForecastCommandInput extends GetPredictiveScalingForecastType {
+}
+export interface GetPredictiveScalingForecastCommandOutput extends GetPredictiveScalingForecastAnswer, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class GetPredictiveScalingForecastCommand extends $Command<GetPredictiveScalingForecastCommandInput, GetPredictiveScalingForecastCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: GetPredictiveScalingForecastCommandInput;
+    constructor(input: GetPredictiveScalingForecastCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPredictiveScalingForecastCommandInput, GetPredictiveScalingForecastCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutLifecycleHookCommand.d.ts

@@ -0,0 +1,72 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { PutLifecycleHookAnswer, PutLifecycleHookType } from "../models/models_0";
+export interface PutLifecycleHookCommandInput extends PutLifecycleHookType {
+}
+export interface PutLifecycleHookCommandOutput extends PutLifecycleHookAnswer, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class PutLifecycleHookCommand extends $Command<PutLifecycleHookCommandInput, PutLifecycleHookCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: PutLifecycleHookCommandInput;
+    constructor(input: PutLifecycleHookCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutLifecycleHookCommandInput, PutLifecycleHookCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutNotificationConfigurationCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { PutNotificationConfigurationType } from "../models/models_0";
+export interface PutNotificationConfigurationCommandInput extends PutNotificationConfigurationType {
+}
+export interface PutNotificationConfigurationCommandOutput extends __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class PutNotificationConfigurationCommand extends $Command<PutNotificationConfigurationCommandInput, PutNotificationConfigurationCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: PutNotificationConfigurationCommandInput;
+    constructor(input: PutNotificationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutNotificationConfigurationCommandInput, PutNotificationConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutScalingPolicyCommand.d.ts

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { PolicyARNType, PutScalingPolicyType } from "../models/models_0";
+export interface PutScalingPolicyCommandInput extends PutScalingPolicyType {
+}
+export interface PutScalingPolicyCommandOutput extends PolicyARNType, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class PutScalingPolicyCommand extends $Command<PutScalingPolicyCommandInput, PutScalingPolicyCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: PutScalingPolicyCommandInput;
+    constructor(input: PutScalingPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutScalingPolicyCommandInput, PutScalingPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutScheduledUpdateGroupActionCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { PutScheduledUpdateGroupActionType } from "../models/models_0";
+export interface PutScheduledUpdateGroupActionCommandInput extends PutScheduledUpdateGroupActionType {
+}
+export interface PutScheduledUpdateGroupActionCommandOutput extends __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class PutScheduledUpdateGroupActionCommand extends $Command<PutScheduledUpdateGroupActionCommandInput, PutScheduledUpdateGroupActionCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: PutScheduledUpdateGroupActionCommandInput;
+    constructor(input: PutScheduledUpdateGroupActionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutScheduledUpdateGroupActionCommandInput, PutScheduledUpdateGroupActionCommandOutput>;
+    private serialize;
+    private deserialize;
+}