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

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

@@ -6,31 +6,11 @@ export interface DeleteLaunchConfigurationCommandInput extends LaunchConfigurati
 }
 export interface DeleteLaunchConfigurationCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified launch configuration.</p>
- *         <p>The launch configuration must not be attached to an Auto Scaling group. When this call
- *             completes, the launch configuration is no longer available for use.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DeleteLaunchConfigurationCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DeleteLaunchConfigurationCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DeleteLaunchConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLaunchConfigurationCommandInput} for command's `input` shape.
- * @see {@link DeleteLaunchConfigurationCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteLaunchConfigurationCommand extends $Command<DeleteLaunchConfigurationCommandInput, DeleteLaunchConfigurationCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DeleteLaunchConfigurationCommandInput;
     constructor(input: DeleteLaunchConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLaunchConfigurationCommandInput, DeleteLaunchConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteLifecycleHookCommandInput extends DeleteLifecycleHookType
 }
 export interface DeleteLifecycleHookCommandOutput extends DeleteLifecycleHookAnswer, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified lifecycle hook.</p>
- *         <p>If there are any outstanding lifecycle actions, they are completed first
- *                 (<code>ABANDON</code> for launching instances, <code>CONTINUE</code> for terminating
- *             instances).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DeleteLifecycleHookCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DeleteLifecycleHookCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DeleteLifecycleHookCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteLifecycleHookCommandInput} for command's `input` shape.
- * @see {@link DeleteLifecycleHookCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteLifecycleHookCommand extends $Command<DeleteLifecycleHookCommandInput, DeleteLifecycleHookCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DeleteLifecycleHookCommandInput;
     constructor(input: DeleteLifecycleHookCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLifecycleHookCommandInput, DeleteLifecycleHookCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteNotificationConfigurationCommandInput extends DeleteNotif
 }
 export interface DeleteNotificationConfigurationCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified notification.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DeleteNotificationConfigurationCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DeleteNotificationConfigurationCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DeleteNotificationConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteNotificationConfigurationCommandInput} for command's `input` shape.
- * @see {@link DeleteNotificationConfigurationCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteNotificationConfigurationCommand extends $Command<DeleteNotificationConfigurationCommandInput, DeleteNotificationConfigurationCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DeleteNotificationConfigurationCommandInput;
     constructor(input: DeleteNotificationConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteNotificationConfigurationCommandInput, DeleteNotificationConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DeletePolicyCommandInput extends DeletePolicyType {
 }
 export interface DeletePolicyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified scaling policy.</p>
- *         <p>Deleting either a step scaling policy or a simple scaling policy deletes the
- *             underlying alarm action, but does not delete the alarm, even if it no longer has an
- *             associated action.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/deleting-scaling-policy.html">Deleting a scaling
- *                 policy</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, DeletePolicyCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DeletePolicyCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DeletePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeletePolicyCommandInput} for command's `input` shape.
- * @see {@link DeletePolicyCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeletePolicyCommand extends $Command<DeletePolicyCommandInput, DeletePolicyCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DeletePolicyCommandInput;
     constructor(input: DeletePolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePolicyCommandInput, DeletePolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteScheduledActionCommandInput extends DeleteScheduledAction
 }
 export interface DeleteScheduledActionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified scheduled action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DeleteScheduledActionCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DeleteScheduledActionCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DeleteScheduledActionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteScheduledActionCommandInput} for command's `input` shape.
- * @see {@link DeleteScheduledActionCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteScheduledActionCommand extends $Command<DeleteScheduledActionCommandInput, DeleteScheduledActionCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DeleteScheduledActionCommandInput;
     constructor(input: DeleteScheduledActionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteScheduledActionCommandInput, DeleteScheduledActionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteTagsCommandInput extends DeleteTagsType {
 }
 export interface DeleteTagsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the specified tags.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DeleteTagsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DeleteTagsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DeleteTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTagsCommandInput} for command's `input` shape.
- * @see {@link DeleteTagsCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteTagsCommand extends $Command<DeleteTagsCommandInput, DeleteTagsCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DeleteTagsCommandInput;
     constructor(input: DeleteTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTagsCommandInput, DeleteTagsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteWarmPoolCommandInput extends DeleteWarmPoolType {
 }
 export interface DeleteWarmPoolCommandOutput extends DeleteWarmPoolAnswer, __MetadataBearer {
 }
-/**
- * <p>Deletes the warm pool for the specified Auto Scaling group.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-warm-pools.html">Warm pools for
- *                 Amazon EC2 Auto Scaling</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DeleteWarmPoolCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DeleteWarmPoolCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DeleteWarmPoolCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteWarmPoolCommandInput} for command's `input` shape.
- * @see {@link DeleteWarmPoolCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteWarmPoolCommand extends $Command<DeleteWarmPoolCommandInput, DeleteWarmPoolCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DeleteWarmPoolCommandInput;
     constructor(input: DeleteWarmPoolCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteWarmPoolCommandInput, DeleteWarmPoolCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DescribeAccountLimitsCommandInput {
 }
 export interface DescribeAccountLimitsCommandOutput extends DescribeAccountLimitsAnswer, __MetadataBearer {
 }
-/**
- * <p>Describes the current Amazon EC2 Auto Scaling resource quotas for your account.</p>
- *         <p>When you establish an account, the account has initial quotas on the maximum
- *             number of Auto Scaling groups and launch configurations that you can create in a given Region.
- *             For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-account-limits.html">Amazon EC2 Auto Scaling service
- *                 quotas</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, DescribeAccountLimitsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeAccountLimitsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeAccountLimitsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAccountLimitsCommandInput} for command's `input` shape.
- * @see {@link DescribeAccountLimitsCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAccountLimitsCommand extends $Command<DescribeAccountLimitsCommandInput, DescribeAccountLimitsCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeAccountLimitsCommandInput;
     constructor(input: DescribeAccountLimitsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccountLimitsCommandInput, DescribeAccountLimitsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,48 +6,11 @@ export interface DescribeAdjustmentTypesCommandInput {
 }
 export interface DescribeAdjustmentTypesCommandOutput extends DescribeAdjustmentTypesAnswer, __MetadataBearer {
 }
-/**
- * <p>Describes the available adjustment types for step scaling and simple scaling
- *             policies.</p>
- *         <p>The following adjustment types are supported:</p>
- *         <ul>
- *             <li>
- *                 <p>
- *                     <code>ChangeInCapacity</code>
- *                 </p>
- *             </li>
- *             <li>
- *                 <p>
- *                     <code>ExactCapacity</code>
- *                 </p>
- *             </li>
- *             <li>
- *                 <p>
- *                     <code>PercentChangeInCapacity</code>
- *                 </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeAdjustmentTypesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeAdjustmentTypesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeAdjustmentTypesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAdjustmentTypesCommandInput} for command's `input` shape.
- * @see {@link DescribeAdjustmentTypesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAdjustmentTypesCommand extends $Command<DescribeAdjustmentTypesCommandInput, DescribeAdjustmentTypesCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeAdjustmentTypesCommandInput;
     constructor(input: DescribeAdjustmentTypesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAdjustmentTypesCommandInput, DescribeAdjustmentTypesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeAutoScalingGroupsCommandInput extends AutoScalingGroupN
 }
 export interface DescribeAutoScalingGroupsCommandOutput extends AutoScalingGroupsType, __MetadataBearer {
 }
-/**
- * <p>Gets information about the Auto Scaling groups in the account and Region.</p>
- *         <p>This operation returns information about instances in Auto Scaling groups. To retrieve
- *             information about the instances in a warm pool, you must call the <a>DescribeWarmPool</a> API. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeAutoScalingGroupsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeAutoScalingGroupsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeAutoScalingGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAutoScalingGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeAutoScalingGroupsCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAutoScalingGroupsCommand extends $Command<DescribeAutoScalingGroupsCommandInput, DescribeAutoScalingGroupsCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeAutoScalingGroupsCommandInput;
     constructor(input: DescribeAutoScalingGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAutoScalingGroupsCommandInput, DescribeAutoScalingGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeAutoScalingInstancesCommandInput extends DescribeAutoSc
 }
 export interface DescribeAutoScalingInstancesCommandOutput extends AutoScalingInstancesType, __MetadataBearer {
 }
-/**
- * <p>Gets information about the Auto Scaling instances in the account and Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeAutoScalingInstancesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeAutoScalingInstancesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeAutoScalingInstancesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAutoScalingInstancesCommandInput} for command's `input` shape.
- * @see {@link DescribeAutoScalingInstancesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAutoScalingInstancesCommand extends $Command<DescribeAutoScalingInstancesCommandInput, DescribeAutoScalingInstancesCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeAutoScalingInstancesCommandInput;
     constructor(input: DescribeAutoScalingInstancesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAutoScalingInstancesCommandInput, DescribeAutoScalingInstancesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeAutoScalingNotificationTypesCommandInput {
 }
 export interface DescribeAutoScalingNotificationTypesCommandOutput extends DescribeAutoScalingNotificationTypesAnswer, __MetadataBearer {
 }
-/**
- * <p>Describes the notification types that are supported by Amazon EC2 Auto Scaling.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeAutoScalingNotificationTypesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeAutoScalingNotificationTypesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeAutoScalingNotificationTypesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAutoScalingNotificationTypesCommandInput} for command's `input` shape.
- * @see {@link DescribeAutoScalingNotificationTypesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeAutoScalingNotificationTypesCommand extends $Command<DescribeAutoScalingNotificationTypesCommandInput, DescribeAutoScalingNotificationTypesCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeAutoScalingNotificationTypesCommandInput;
     constructor(input: DescribeAutoScalingNotificationTypesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAutoScalingNotificationTypesCommandInput, DescribeAutoScalingNotificationTypesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,67 +6,11 @@ export interface DescribeInstanceRefreshesCommandInput extends DescribeInstanceR
 }
 export interface DescribeInstanceRefreshesCommandOutput extends DescribeInstanceRefreshesAnswer, __MetadataBearer {
 }
-/**
- * <p>Gets information about the instance refreshes for the specified 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
- *             after you make configuration changes.</p>
- *         <p>To help you determine the status of an instance refresh, this operation returns
- *             information about the instance refreshes you previously initiated, including their
- *             status, end time, the percentage of the instance refresh that is complete, and the
- *             number of instances remaining to update before the instance refresh is complete.</p>
- *         <p>The following are the possible statuses: </p>
- *         <ul>
- *             <li>
- *                 <p>
- *                   <code>Pending</code> - The request was created, but the operation has not
- *                     started.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>InProgress</code> - The operation is in progress.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>Successful</code> - The operation completed successfully.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>Failed</code> - The operation failed to complete. You can troubleshoot
- *                     using the status reason and the scaling activities. </p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>Cancelling</code> - An ongoing operation is being cancelled.
- *                     Cancellation does not roll back any replacements that have already been
- *                     completed, but it prevents new replacements from being started. </p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <code>Cancelled</code> - The operation is cancelled. </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeInstanceRefreshesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeInstanceRefreshesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeInstanceRefreshesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeInstanceRefreshesCommandInput} for command's `input` shape.
- * @see {@link DescribeInstanceRefreshesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeInstanceRefreshesCommand extends $Command<DescribeInstanceRefreshesCommandInput, DescribeInstanceRefreshesCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeInstanceRefreshesCommandInput;
     constructor(input: DescribeInstanceRefreshesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeInstanceRefreshesCommandInput, DescribeInstanceRefreshesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeLaunchConfigurationsCommandInput extends LaunchConfigur
 }
 export interface DescribeLaunchConfigurationsCommandOutput extends LaunchConfigurationsType, __MetadataBearer {
 }
-/**
- * <p>Gets information about the launch configurations in the account and Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeLaunchConfigurationsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeLaunchConfigurationsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeLaunchConfigurationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLaunchConfigurationsCommandInput} for command's `input` shape.
- * @see {@link DescribeLaunchConfigurationsCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLaunchConfigurationsCommand extends $Command<DescribeLaunchConfigurationsCommandInput, DescribeLaunchConfigurationsCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeLaunchConfigurationsCommandInput;
     constructor(input: DescribeLaunchConfigurationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLaunchConfigurationsCommandInput, DescribeLaunchConfigurationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface DescribeLifecycleHookTypesCommandInput {
 }
 export interface DescribeLifecycleHookTypesCommandOutput extends DescribeLifecycleHookTypesAnswer, __MetadataBearer {
 }
-/**
- * <p>Describes the available types of lifecycle hooks.</p>
- *         <p>The following hook types are supported:</p>
- *         <ul>
- *             <li>
- *                 <p>
- *                     <code>autoscaling:EC2_INSTANCE_LAUNCHING</code>
- *                 </p>
- *             </li>
- *             <li>
- *                 <p>
- *                     <code>autoscaling:EC2_INSTANCE_TERMINATING</code>
- *                 </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeLifecycleHookTypesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeLifecycleHookTypesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeLifecycleHookTypesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLifecycleHookTypesCommandInput} for command's `input` shape.
- * @see {@link DescribeLifecycleHookTypesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLifecycleHookTypesCommand extends $Command<DescribeLifecycleHookTypesCommandInput, DescribeLifecycleHookTypesCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeLifecycleHookTypesCommandInput;
     constructor(input: DescribeLifecycleHookTypesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLifecycleHookTypesCommandInput, DescribeLifecycleHookTypesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeLifecycleHooksCommandInput extends DescribeLifecycleHoo
 }
 export interface DescribeLifecycleHooksCommandOutput extends DescribeLifecycleHooksAnswer, __MetadataBearer {
 }
-/**
- * <p>Gets information about the lifecycle hooks for the specified Auto Scaling group.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeLifecycleHooksCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeLifecycleHooksCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeLifecycleHooksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLifecycleHooksCommandInput} for command's `input` shape.
- * @see {@link DescribeLifecycleHooksCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLifecycleHooksCommand extends $Command<DescribeLifecycleHooksCommandInput, DescribeLifecycleHooksCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeLifecycleHooksCommandInput;
     constructor(input: DescribeLifecycleHooksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLifecycleHooksCommandInput, DescribeLifecycleHooksCommandOutput>;
     private serialize;
     private deserialize;