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

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

@@ -6,48 +6,11 @@ export interface DescribeLoadBalancerTargetGroupsCommandInput extends DescribeLo
 }
 export interface DescribeLoadBalancerTargetGroupsCommandOutput extends DescribeLoadBalancerTargetGroupsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about the load balancer target groups for the specified Auto Scaling
- *             group.</p>
- *         <p>To determine the availability of registered instances, use the <code>State</code>
- *             element in the response. When you attach a target group to an Auto Scaling group, the initial
- *                 <code>State</code> value is <code>Adding</code>. The state transitions to
- *                 <code>Added</code> after all Auto Scaling instances are registered with the target group. If
- *             Elastic Load Balancing health checks are enabled for the Auto Scaling group, the state transitions to
- *                 <code>InService</code> after at least one Auto Scaling instance passes the health check.
- *             When the target group is in the <code>InService</code> state, Amazon EC2 Auto Scaling can terminate and
- *             replace any instances that are reported as unhealthy. If no registered instances pass
- *             the health checks, the target group doesn't enter the <code>InService</code> state. </p>
- *         <p>Target groups also have an <code>InService</code> state if you attach them in the
- *                 <a>CreateAutoScalingGroup</a> API call. If your target group state is
- *                 <code>InService</code>, but it is not working properly, check the scaling activities
- *             by calling <a>DescribeScalingActivities</a> and take any corrective actions
- *             necessary.</p>
- *         <p>For help with failed health checks, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ts-as-healthchecks.html">Troubleshooting Amazon EC2 Auto Scaling:
- *                 Health checks</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>. For more
- *             information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/autoscaling-load-balancer.html">Elastic Load Balancing and
- *                 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, DescribeLoadBalancerTargetGroupsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeLoadBalancerTargetGroupsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeLoadBalancerTargetGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLoadBalancerTargetGroupsCommandInput} for command's `input` shape.
- * @see {@link DescribeLoadBalancerTargetGroupsCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLoadBalancerTargetGroupsCommand extends $Command<DescribeLoadBalancerTargetGroupsCommandInput, DescribeLoadBalancerTargetGroupsCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeLoadBalancerTargetGroupsCommandInput;
     constructor(input: DescribeLoadBalancerTargetGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLoadBalancerTargetGroupsCommandInput, DescribeLoadBalancerTargetGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,50 +6,11 @@ export interface DescribeLoadBalancersCommandInput extends DescribeLoadBalancers
 }
 export interface DescribeLoadBalancersCommandOutput extends DescribeLoadBalancersResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about the load balancers for the specified Auto Scaling group.</p>
- *         <p>This operation describes only Classic Load Balancers. If you have Application Load
- *             Balancers, Network Load Balancers, or Gateway Load Balancers, use the <a>DescribeLoadBalancerTargetGroups</a> API instead.</p>
- *         <p>To determine the availability of registered instances, use the <code>State</code>
- *             element in the response. When you attach a load balancer to an Auto Scaling group, the initial
- *                 <code>State</code> value is <code>Adding</code>. The state transitions to
- *                 <code>Added</code> after all Auto Scaling instances are registered with the load balancer.
- *             If Elastic Load Balancing health checks are enabled for the Auto Scaling group, the state transitions to
- *                 <code>InService</code> after at least one Auto Scaling instance passes the health check.
- *             When the load balancer is in the <code>InService</code> state, Amazon EC2 Auto Scaling can terminate
- *             and replace any instances that are reported as unhealthy. If no registered instances
- *             pass the health checks, the load balancer doesn't enter the <code>InService</code>
- *             state. </p>
- *         <p>Load balancers also have an <code>InService</code> state if you attach them in the
- *                 <a>CreateAutoScalingGroup</a> API call. If your load balancer state is
- *                 <code>InService</code>, but it is not working properly, check the scaling activities
- *             by calling <a>DescribeScalingActivities</a> and take any corrective actions
- *             necessary.</p>
- *         <p>For help with failed health checks, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ts-as-healthchecks.html">Troubleshooting Amazon EC2 Auto Scaling:
- *                 Health checks</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>. For more
- *             information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/autoscaling-load-balancer.html">Elastic Load Balancing and
- *                 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, DescribeLoadBalancersCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeLoadBalancersCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeLoadBalancersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeLoadBalancersCommandInput} for command's `input` shape.
- * @see {@link DescribeLoadBalancersCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeLoadBalancersCommand extends $Command<DescribeLoadBalancersCommandInput, DescribeLoadBalancersCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeLoadBalancersCommandInput;
     constructor(input: DescribeLoadBalancersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeLoadBalancersCommandInput, DescribeLoadBalancersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeMetricCollectionTypesCommandInput {
 }
 export interface DescribeMetricCollectionTypesCommandOutput extends DescribeMetricCollectionTypesAnswer, __MetadataBearer {
 }
-/**
- * <p>Describes the available CloudWatch metrics for Amazon EC2 Auto Scaling.</p>
- *         <p>The <code>GroupStandbyInstances</code> metric is not returned by default. You must
- *             explicitly request this metric when calling the <a>EnableMetricsCollection</a> API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeMetricCollectionTypesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeMetricCollectionTypesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeMetricCollectionTypesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeMetricCollectionTypesCommandInput} for command's `input` shape.
- * @see {@link DescribeMetricCollectionTypesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeMetricCollectionTypesCommand extends $Command<DescribeMetricCollectionTypesCommandInput, DescribeMetricCollectionTypesCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeMetricCollectionTypesCommandInput;
     constructor(input: DescribeMetricCollectionTypesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeMetricCollectionTypesCommandInput, DescribeMetricCollectionTypesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeNotificationConfigurationsCommandInput extends Describe
 }
 export interface DescribeNotificationConfigurationsCommandOutput extends DescribeNotificationConfigurationsAnswer, __MetadataBearer {
 }
-/**
- * <p>Gets information about the Amazon SNS notifications that are configured for one or more
- *             Auto Scaling groups.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeNotificationConfigurationsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeNotificationConfigurationsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeNotificationConfigurationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeNotificationConfigurationsCommandInput} for command's `input` shape.
- * @see {@link DescribeNotificationConfigurationsCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeNotificationConfigurationsCommand extends $Command<DescribeNotificationConfigurationsCommandInput, DescribeNotificationConfigurationsCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeNotificationConfigurationsCommandInput;
     constructor(input: DescribeNotificationConfigurationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeNotificationConfigurationsCommandInput, DescribeNotificationConfigurationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribePoliciesCommandInput extends DescribePoliciesType {
 }
 export interface DescribePoliciesCommandOutput extends PoliciesType, __MetadataBearer {
 }
-/**
- * <p>Gets information about the scaling policies 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, DescribePoliciesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribePoliciesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribePoliciesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePoliciesCommandInput} for command's `input` shape.
- * @see {@link DescribePoliciesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribePoliciesCommand extends $Command<DescribePoliciesCommandInput, DescribePoliciesCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribePoliciesCommandInput;
     constructor(input: DescribePoliciesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePoliciesCommandInput, DescribePoliciesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface DescribeScalingActivitiesCommandInput extends DescribeScalingAc
 }
 export interface DescribeScalingActivitiesCommandOutput extends ActivitiesType, __MetadataBearer {
 }
-/**
- * <p>Gets information about the scaling activities in the account and Region.</p>
- *         <p>When scaling events occur, you see a record of the scaling activity in the scaling
- *             activities. For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-verify-scaling-activity.html">Verifying a scaling
- *                 activity for an Auto Scaling group</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
- *         <p>If the scaling event succeeds, the value of the <code>StatusCode</code> element in the
- *             response is <code>Successful</code>. If an attempt to launch instances failed, the
- *                 <code>StatusCode</code> value is <code>Failed</code> or <code>Cancelled</code> and
- *             the <code>StatusMessage</code> element in the response indicates the cause of the
- *             failure. For help interpreting the <code>StatusMessage</code>, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/CHAP_Troubleshooting.html">Troubleshooting 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, DescribeScalingActivitiesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeScalingActivitiesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeScalingActivitiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeScalingActivitiesCommandInput} for command's `input` shape.
- * @see {@link DescribeScalingActivitiesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeScalingActivitiesCommand extends $Command<DescribeScalingActivitiesCommandInput, DescribeScalingActivitiesCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeScalingActivitiesCommandInput;
     constructor(input: DescribeScalingActivitiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeScalingActivitiesCommandInput, DescribeScalingActivitiesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface DescribeScheduledActionsCommandInput extends DescribeScheduledA
 }
 export interface DescribeScheduledActionsCommandOutput extends ScheduledActionsType, __MetadataBearer {
 }
-/**
- * <p>Gets information about the scheduled actions that haven't run or that have not reached
- *             their end time.</p>
- *         <p>To describe the scaling activities for scheduled actions that have already run, call
- *             the <a>DescribeScalingActivities</a> API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeScheduledActionsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeScheduledActionsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeScheduledActionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeScheduledActionsCommandInput} for command's `input` shape.
- * @see {@link DescribeScheduledActionsCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeScheduledActionsCommand extends $Command<DescribeScheduledActionsCommandInput, DescribeScheduledActionsCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeScheduledActionsCommandInput;
     constructor(input: DescribeScheduledActionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeScheduledActionsCommandInput, DescribeScheduledActionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface DescribeTagsCommandInput extends DescribeTagsType {
 }
 export interface DescribeTagsCommandOutput extends TagsType, __MetadataBearer {
 }
-/**
- * <p>Describes the specified tags.</p>
- *         <p>You can use filters to limit the results. For example, you can query for the tags for
- *             a specific Auto Scaling group. You can specify multiple values for a filter. A tag must match at
- *             least one of the specified values for it to be included in the results.</p>
- *         <p>You can also specify multiple filters. The result includes information for a
- *             particular tag only if it matches all the filters. If there's no match, no special
- *             message is returned.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/autoscaling-tagging.html">Tagging Auto Scaling groups and
- *                 instances</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, DescribeTagsCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeTagsCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTagsCommandInput} for command's `input` shape.
- * @see {@link DescribeTagsCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTagsCommand extends $Command<DescribeTagsCommandInput, DescribeTagsCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeTagsCommandInput;
     constructor(input: DescribeTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTagsCommandInput, DescribeTagsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeTerminationPolicyTypesCommandInput {
 }
 export interface DescribeTerminationPolicyTypesCommandOutput extends DescribeTerminationPolicyTypesAnswer, __MetadataBearer {
 }
-/**
- * <p>Describes the termination policies supported by Amazon EC2 Auto Scaling.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html">Controlling which Auto Scaling
- *                 instances terminate during scale in</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, DescribeTerminationPolicyTypesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, DescribeTerminationPolicyTypesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new DescribeTerminationPolicyTypesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTerminationPolicyTypesCommandInput} for command's `input` shape.
- * @see {@link DescribeTerminationPolicyTypesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTerminationPolicyTypesCommand extends $Command<DescribeTerminationPolicyTypesCommandInput, DescribeTerminationPolicyTypesCommandOutput, AutoScalingClientResolvedConfig> {
     readonly input: DescribeTerminationPolicyTypesCommandInput;
     constructor(input: DescribeTerminationPolicyTypesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTerminationPolicyTypesCommandInput, DescribeTerminationPolicyTypesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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