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

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

@@ -6,38 +6,11 @@ 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/ts3.4/commands/ExecutePolicyCommand.d.ts

@@ -6,30 +6,11 @@ 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/ts3.4/commands/ExitStandbyCommand.d.ts

@@ -6,34 +6,11 @@ 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/ts3.4/commands/GetPredictiveScalingForecastCommand.d.ts

@@ -6,37 +6,11 @@ export interface GetPredictiveScalingForecastCommandInput extends GetPredictiveS
 }
 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/ts3.4/commands/PutLifecycleHookCommand.d.ts

@@ -6,66 +6,11 @@ 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/ts3.4/commands/PutNotificationConfigurationCommand.d.ts

@@ -6,37 +6,11 @@ export interface PutNotificationConfigurationCommandInput extends PutNotificatio
 }
 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/ts3.4/commands/PutScalingPolicyCommand.d.ts

@@ -6,38 +6,11 @@ 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/ts3.4/commands/PutScheduledUpdateGroupActionCommand.d.ts

@@ -6,33 +6,11 @@ export interface PutScheduledUpdateGroupActionCommandInput extends PutScheduledU
 }
 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;

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

@@ -6,38 +6,11 @@ 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

@@ -6,61 +6,11 @@ export interface RecordLifecycleActionHeartbeatCommandInput extends RecordLifecy
 }
 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

@@ -6,32 +6,11 @@ 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

@@ -6,34 +6,11 @@ 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

@@ -6,31 +6,11 @@ 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

@@ -6,35 +6,11 @@ export interface SetInstanceProtectionCommandInput extends SetInstanceProtection
 }
 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;