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

package/dist-types/commands/PutWarmPoolCommand.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 { PutWarmPoolAnswer, PutWarmPoolType } from "../models/models_0";
+export interface PutWarmPoolCommandInput extends PutWarmPoolType {
+}
+export interface PutWarmPoolCommandOutput extends PutWarmPoolAnswer, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class PutWarmPoolCommand extends $Command<PutWarmPoolCommandInput, PutWarmPoolCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: PutWarmPoolCommandInput;
+    constructor(input: PutWarmPoolCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutWarmPoolCommandInput, PutWarmPoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,67 @@
+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 { RecordLifecycleActionHeartbeatAnswer, RecordLifecycleActionHeartbeatType } from "../models/models_0";
+export interface RecordLifecycleActionHeartbeatCommandInput extends RecordLifecycleActionHeartbeatType {
+}
+export interface RecordLifecycleActionHeartbeatCommandOutput extends RecordLifecycleActionHeartbeatAnswer, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class RecordLifecycleActionHeartbeatCommand extends $Command<RecordLifecycleActionHeartbeatCommandInput, RecordLifecycleActionHeartbeatCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: RecordLifecycleActionHeartbeatCommandInput;
+    constructor(input: RecordLifecycleActionHeartbeatCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RecordLifecycleActionHeartbeatCommandInput, RecordLifecycleActionHeartbeatCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ScalingProcessQuery } from "../models/models_0";
+export interface ResumeProcessesCommandInput extends ScalingProcessQuery {
+}
+export interface ResumeProcessesCommandOutput extends __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class ResumeProcessesCommand extends $Command<ResumeProcessesCommandInput, ResumeProcessesCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: ResumeProcessesCommandInput;
+    constructor(input: ResumeProcessesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResumeProcessesCommandInput, ResumeProcessesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetDesiredCapacityCommand.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 { SetDesiredCapacityType } from "../models/models_0";
+export interface SetDesiredCapacityCommandInput extends SetDesiredCapacityType {
+}
+export interface SetDesiredCapacityCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Sets the size of the specified Auto Scaling group.</p>
+ *         <p>If a scale-in activity occurs as a result of a new <code>DesiredCapacity</code> value
+ *             that is lower than the current size of the group, the Auto Scaling group uses its termination
+ *             policy to determine which instances to terminate. </p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-manual-scaling.html">Manual 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, SetDesiredCapacityCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, SetDesiredCapacityCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new SetDesiredCapacityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetDesiredCapacityCommandInput} for command's `input` shape.
+ * @see {@link SetDesiredCapacityCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetDesiredCapacityCommand extends $Command<SetDesiredCapacityCommandInput, SetDesiredCapacityCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: SetDesiredCapacityCommandInput;
+    constructor(input: SetDesiredCapacityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetDesiredCapacityCommandInput, SetDesiredCapacityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetInstanceHealthCommand.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 { SetInstanceHealthQuery } from "../models/models_0";
+export interface SetInstanceHealthCommandInput extends SetInstanceHealthQuery {
+}
+export interface SetInstanceHealthCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Sets the health status of the specified instance.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/healthcheck.html">Health checks for Auto Scaling
+ *                 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, SetInstanceHealthCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, SetInstanceHealthCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new SetInstanceHealthCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetInstanceHealthCommandInput} for command's `input` shape.
+ * @see {@link SetInstanceHealthCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetInstanceHealthCommand extends $Command<SetInstanceHealthCommandInput, SetInstanceHealthCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: SetInstanceHealthCommandInput;
+    constructor(input: SetInstanceHealthCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetInstanceHealthCommandInput, SetInstanceHealthCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,41 @@
+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 { SetInstanceProtectionAnswer, SetInstanceProtectionQuery } from "../models/models_0";
+export interface SetInstanceProtectionCommandInput extends SetInstanceProtectionQuery {
+}
+export interface SetInstanceProtectionCommandOutput extends SetInstanceProtectionAnswer, __MetadataBearer {
+}
+/**
+ * <p>Updates the instance protection settings of the specified instances. This operation
+ *             cannot be called on instances in a warm pool.</p>
+ *         <p>For more information about preventing instances that are part of an Auto Scaling group from
+ *             terminating on scale in, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection">Instance scale-in protection</a> in the
+ *             <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ *         <p>If you exceed your maximum limit of instance IDs, which is 50 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, SetInstanceProtectionCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, SetInstanceProtectionCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new SetInstanceProtectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetInstanceProtectionCommandInput} for command's `input` shape.
+ * @see {@link SetInstanceProtectionCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetInstanceProtectionCommand extends $Command<SetInstanceProtectionCommandInput, SetInstanceProtectionCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: SetInstanceProtectionCommandInput;
+    constructor(input: SetInstanceProtectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetInstanceProtectionCommandInput, SetInstanceProtectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,49 @@
+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 { StartInstanceRefreshAnswer, StartInstanceRefreshType } from "../models/models_0";
+export interface StartInstanceRefreshCommandInput extends StartInstanceRefreshType {
+}
+export interface StartInstanceRefreshCommandOutput extends StartInstanceRefreshAnswer, __MetadataBearer {
+}
+/**
+ * <p>Starts a new instance refresh operation. An instance refresh performs a rolling
+ *             replacement of all or some instances in an Auto Scaling group. Each instance is terminated first
+ *             and then replaced, which temporarily reduces the capacity available within your Auto Scaling
+ *             group.</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.
+ *             This feature is helpful, for example, when you have a new AMI or a new user data script.
+ *             You just need to create a new launch template that specifies the new AMI or user data
+ *             script. Then start an instance refresh to immediately begin the process of updating
+ *             instances in the group. </p>
+ *         <p>If the call succeeds, it creates a new instance refresh request with a unique ID that
+ *             you can use to track its progress. To query its status, call the <a>DescribeInstanceRefreshes</a> API. To describe the instance refreshes that
+ *             have already run, call the <a>DescribeInstanceRefreshes</a> API. To cancel an
+ *             instance refresh operation in progress, use the <a>CancelInstanceRefresh</a>
+ *             API. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, StartInstanceRefreshCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, StartInstanceRefreshCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new StartInstanceRefreshCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartInstanceRefreshCommandInput} for command's `input` shape.
+ * @see {@link StartInstanceRefreshCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StartInstanceRefreshCommand extends $Command<StartInstanceRefreshCommandInput, StartInstanceRefreshCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: StartInstanceRefreshCommandInput;
+    constructor(input: StartInstanceRefreshCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartInstanceRefreshCommandInput, StartInstanceRefreshCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,41 @@
+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 { ScalingProcessQuery } from "../models/models_0";
+export interface SuspendProcessesCommandInput extends ScalingProcessQuery {
+}
+export interface SuspendProcessesCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Suspends the specified auto scaling processes, or all processes, for the specified
+ *             Auto Scaling group.</p>
+ *         <p>If you suspend either the <code>Launch</code> or <code>Terminate</code> process types,
+ *             it can prevent other process types from functioning properly. 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>
+ *         <p>To resume processes that have been suspended, call the <a>ResumeProcesses</a> API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, SuspendProcessesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, SuspendProcessesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new SuspendProcessesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SuspendProcessesCommandInput} for command's `input` shape.
+ * @see {@link SuspendProcessesCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SuspendProcessesCommand extends $Command<SuspendProcessesCommandInput, SuspendProcessesCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: SuspendProcessesCommandInput;
+    constructor(input: SuspendProcessesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SuspendProcessesCommandInput, SuspendProcessesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,46 @@
+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 { ActivityType, TerminateInstanceInAutoScalingGroupType } from "../models/models_0";
+export interface TerminateInstanceInAutoScalingGroupCommandInput extends TerminateInstanceInAutoScalingGroupType {
+}
+export interface TerminateInstanceInAutoScalingGroupCommandOutput extends ActivityType, __MetadataBearer {
+}
+/**
+ * <p>Terminates the specified instance and optionally adjusts the desired group size. This
+ *             operation cannot be called on instances in a warm pool.</p>
+ *         <p>This call simply makes a termination request. The instance is not terminated
+ *             immediately. When an instance is terminated, the instance status changes to
+ *                 <code>terminated</code>. You can't connect to or start an instance after you've
+ *             terminated it.</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 terminated. </p>
+ *         <p>By default, Amazon EC2 Auto Scaling balances instances across all Availability Zones. If you
+ *             decrement the desired capacity, your Auto Scaling group can become unbalanced between
+ *             Availability Zones. Amazon EC2 Auto Scaling tries to rebalance the group, and rebalancing might
+ *             terminate instances in other zones. For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/auto-scaling-benefits.html#AutoScalingBehavior.InstanceUsage">Rebalancing activities</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, TerminateInstanceInAutoScalingGroupCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, TerminateInstanceInAutoScalingGroupCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new TerminateInstanceInAutoScalingGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TerminateInstanceInAutoScalingGroupCommandInput} for command's `input` shape.
+ * @see {@link TerminateInstanceInAutoScalingGroupCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TerminateInstanceInAutoScalingGroupCommand extends $Command<TerminateInstanceInAutoScalingGroupCommandInput, TerminateInstanceInAutoScalingGroupCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: TerminateInstanceInAutoScalingGroupCommandInput;
+    constructor(input: TerminateInstanceInAutoScalingGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TerminateInstanceInAutoScalingGroupCommandInput, TerminateInstanceInAutoScalingGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,79 @@
+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 { UpdateAutoScalingGroupType } from "../models/models_0";
+export interface UpdateAutoScalingGroupCommandInput extends UpdateAutoScalingGroupType {
+}
+export interface UpdateAutoScalingGroupCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>
+ *             <b>We strongly recommend that all Auto Scaling groups use launch templates to ensure full functionality for Amazon EC2 Auto Scaling and Amazon EC2.</b>
+ *          </p>
+ *          <p>Updates the configuration for
+ *             the specified Auto Scaling group.</p>
+ *         <p>To update an Auto Scaling group, specify the name of the group and the parameter that you want
+ *             to change. Any parameters that you don't specify are not changed by this update request.
+ *             The new settings take effect on any scaling activities after this call returns.
+ *             </p>
+ *         <p>If you associate a new launch configuration or template with an Auto Scaling group, all new
+ *             instances will get the updated configuration. Existing instances continue to run with
+ *             the configuration that they were originally launched with. When you update a group to
+ *             specify a mixed instances policy instead of a launch configuration or template, existing
+ *             instances may be replaced to match the new purchasing options that you specified in the
+ *             policy. For example, if the group currently has 100% On-Demand capacity and the policy
+ *             specifies 50% Spot capacity, this means that half of your instances will be gradually
+ *             terminated and relaunched as Spot Instances. When replacing instances, Amazon EC2 Auto Scaling launches
+ *             new instances before terminating the old ones, so that updating your group does not
+ *             compromise the performance or availability of your application.</p>
+ *         <p>Note the following about changing <code>DesiredCapacity</code>, <code>MaxSize</code>,
+ *             or <code>MinSize</code>:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>If a scale-in activity occurs as a result of a new
+ *                         <code>DesiredCapacity</code> value that is lower than the current size of
+ *                     the group, the Auto Scaling group uses its termination policy to determine which
+ *                     instances to terminate.</p>
+ *             </li>
+ *             <li>
+ *                 <p>If you specify a new value for <code>MinSize</code> without specifying a value
+ *                     for <code>DesiredCapacity</code>, and the new <code>MinSize</code> is larger
+ *                     than the current size of the group, this sets the group's
+ *                         <code>DesiredCapacity</code> to the new <code>MinSize</code> value.</p>
+ *             </li>
+ *             <li>
+ *                 <p>If you specify a new value for <code>MaxSize</code> without specifying a value
+ *                     for <code>DesiredCapacity</code>, and the new <code>MaxSize</code> is smaller
+ *                     than the current size of the group, this sets the group's
+ *                         <code>DesiredCapacity</code> to the new <code>MaxSize</code> value.</p>
+ *             </li>
+ *          </ul>
+ *         <p>To see which parameters have been set, call the <a>DescribeAutoScalingGroups</a> API. To view the scaling policies for an Auto Scaling
+ *             group, call the <a>DescribePolicies</a> API. If the group has scaling
+ *             policies, you can update them by calling the <a>PutScalingPolicy</a>
+ *             API.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, UpdateAutoScalingGroupCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, UpdateAutoScalingGroupCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new UpdateAutoScalingGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateAutoScalingGroupCommandInput} for command's `input` shape.
+ * @see {@link UpdateAutoScalingGroupCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateAutoScalingGroupCommand extends $Command<UpdateAutoScalingGroupCommandInput, UpdateAutoScalingGroupCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: UpdateAutoScalingGroupCommandInput;
+    constructor(input: UpdateAutoScalingGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAutoScalingGroupCommandInput, UpdateAutoScalingGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/pagination/DescribeAutoScalingGroupsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeAutoScalingGroupsCommandInput, DescribeAutoScalingGroupsCommandOutput } from "../commands/DescribeAutoScalingGroupsCommand";
+import { AutoScalingPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeAutoScalingGroups(config: AutoScalingPaginationConfiguration, input: DescribeAutoScalingGroupsCommandInput, ...additionalArguments: any): Paginator<DescribeAutoScalingGroupsCommandOutput>;

package/dist-types/pagination/DescribeAutoScalingInstancesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeAutoScalingInstancesCommandInput, DescribeAutoScalingInstancesCommandOutput } from "../commands/DescribeAutoScalingInstancesCommand";
+import { AutoScalingPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeAutoScalingInstances(config: AutoScalingPaginationConfiguration, input: DescribeAutoScalingInstancesCommandInput, ...additionalArguments: any): Paginator<DescribeAutoScalingInstancesCommandOutput>;

package/dist-types/pagination/DescribeLaunchConfigurationsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeLaunchConfigurationsCommandInput, DescribeLaunchConfigurationsCommandOutput } from "../commands/DescribeLaunchConfigurationsCommand";
+import { AutoScalingPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeLaunchConfigurations(config: AutoScalingPaginationConfiguration, input: DescribeLaunchConfigurationsCommandInput, ...additionalArguments: any): Paginator<DescribeLaunchConfigurationsCommandOutput>;

package/dist-types/pagination/DescribeNotificationConfigurationsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeNotificationConfigurationsCommandInput, DescribeNotificationConfigurationsCommandOutput } from "../commands/DescribeNotificationConfigurationsCommand";
+import { AutoScalingPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeNotificationConfigurations(config: AutoScalingPaginationConfiguration, input: DescribeNotificationConfigurationsCommandInput, ...additionalArguments: any): Paginator<DescribeNotificationConfigurationsCommandOutput>;

package/dist-types/pagination/DescribePoliciesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribePoliciesCommandInput, DescribePoliciesCommandOutput } from "../commands/DescribePoliciesCommand";
+import { AutoScalingPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribePolicies(config: AutoScalingPaginationConfiguration, input: DescribePoliciesCommandInput, ...additionalArguments: any): Paginator<DescribePoliciesCommandOutput>;

package/dist-types/pagination/DescribeScalingActivitiesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeScalingActivitiesCommandInput, DescribeScalingActivitiesCommandOutput } from "../commands/DescribeScalingActivitiesCommand";
+import { AutoScalingPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeScalingActivities(config: AutoScalingPaginationConfiguration, input: DescribeScalingActivitiesCommandInput, ...additionalArguments: any): Paginator<DescribeScalingActivitiesCommandOutput>;

package/dist-types/pagination/DescribeScheduledActionsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeScheduledActionsCommandInput, DescribeScheduledActionsCommandOutput } from "../commands/DescribeScheduledActionsCommand";
+import { AutoScalingPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeScheduledActions(config: AutoScalingPaginationConfiguration, input: DescribeScheduledActionsCommandInput, ...additionalArguments: any): Paginator<DescribeScheduledActionsCommandOutput>;

package/dist-types/pagination/DescribeTagsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeTagsCommandInput, DescribeTagsCommandOutput } from "../commands/DescribeTagsCommand";
+import { AutoScalingPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeTags(config: AutoScalingPaginationConfiguration, input: DescribeTagsCommandInput, ...additionalArguments: any): Paginator<DescribeTagsCommandOutput>;

package/dist-types/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { AutoScaling } from "../AutoScaling";
+import { AutoScalingClient } from "../AutoScalingClient";
+export interface AutoScalingPaginationConfiguration extends PaginationConfiguration {
+    client: AutoScaling | AutoScalingClient;
+}