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

package/dist/types/ts3.4/commands/PutWarmPoolCommand.d.ts

@@ -1,44 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { PutWarmPoolAnswer, PutWarmPoolType } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/RecordLifecycleActionHeartbeatCommand.d.ts

@@ -1,67 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { RecordLifecycleActionHeartbeatAnswer, RecordLifecycleActionHeartbeatType } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/ResumeProcessesCommand.d.ts

@@ -1,38 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { ScalingProcessQuery } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/SetDesiredCapacityCommand.d.ts

@@ -1,40 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { SetDesiredCapacityType } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/SetInstanceHealthCommand.d.ts

@@ -1,37 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { SetInstanceHealthQuery } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/SetInstanceProtectionCommand.d.ts

@@ -1,41 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { SetInstanceProtectionAnswer, SetInstanceProtectionQuery } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/StartInstanceRefreshCommand.d.ts

@@ -1,49 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { StartInstanceRefreshAnswer, StartInstanceRefreshType } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/SuspendProcessesCommand.d.ts

@@ -1,41 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { ScalingProcessQuery } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/TerminateInstanceInAutoScalingGroupCommand.d.ts

@@ -1,46 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { ActivityType, TerminateInstanceInAutoScalingGroupType } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/commands/UpdateAutoScalingGroupCommand.d.ts

@@ -1,79 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { UpdateAutoScalingGroupType } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/ts3.4/pagination/DescribeAutoScalingGroupsPaginator.d.ts

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

package/dist/types/ts3.4/pagination/DescribeAutoScalingInstancesPaginator.d.ts

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

package/dist/types/ts3.4/pagination/DescribeLaunchConfigurationsPaginator.d.ts

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

package/dist/types/ts3.4/pagination/DescribeNotificationConfigurationsPaginator.d.ts

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

package/dist/types/ts3.4/pagination/DescribePoliciesPaginator.d.ts

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

package/dist/types/ts3.4/pagination/DescribeScalingActivitiesPaginator.d.ts

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

package/dist/types/ts3.4/pagination/DescribeScheduledActionsPaginator.d.ts

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

package/dist/types/ts3.4/pagination/DescribeTagsPaginator.d.ts

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

package/dist/types/ts3.4/pagination/Interfaces.d.ts

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