@aws-sdk/client-auto-scaling 3.315.0 → 3.319.0

package/dist-types/AutoScaling.d.ts

@@ -65,1092 +65,404 @@ import { StartInstanceRefreshCommandInput, StartInstanceRefreshCommandOutput } f
 import { SuspendProcessesCommandInput, SuspendProcessesCommandOutput } from "./commands/SuspendProcessesCommand";
 import { TerminateInstanceInAutoScalingGroupCommandInput, TerminateInstanceInAutoScalingGroupCommandOutput } from "./commands/TerminateInstanceInAutoScalingGroupCommand";
 import { UpdateAutoScalingGroupCommandInput, UpdateAutoScalingGroupCommandOutput } from "./commands/UpdateAutoScalingGroupCommand";
-/**
- * @public
- * <fullname>Amazon EC2 Auto Scaling</fullname>
- *          <p>Amazon EC2 Auto Scaling is designed to automatically launch and terminate EC2 instances
- *             based on user-defined scaling policies, scheduled actions, and health checks.</p>
- *          <p>For more information, see the <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/">Amazon EC2 Auto Scaling User Guide</a> and the <a href="https://docs.aws.amazon.com/autoscaling/ec2/APIReference/Welcome.html">Amazon EC2 Auto Scaling API Reference</a>.</p>
- */
-export declare class AutoScaling extends AutoScalingClient {
-    /**
-     * @public
-     * <p>Attaches one or more EC2 instances to the specified Auto Scaling group.</p>
-     *          <p>When you attach instances, Amazon EC2 Auto Scaling increases the desired capacity of the group by the
-     *             number of instances being attached. If the number of instances being attached plus the
-     *             desired capacity of the group exceeds the maximum size of the group, the operation
-     *             fails.</p>
-     *          <p>If there is a Classic Load Balancer attached to your Auto Scaling group, the instances are
-     *             also registered with the load balancer. If there are target groups attached to your Auto Scaling
-     *             group, the instances are also registered with the target groups.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/attach-instance-asg.html">Attach EC2 instances to
-     *                 your Auto Scaling group</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+export interface AutoScaling {
+    /**
+     * @see {@link AttachInstancesCommand}
      */
     attachInstances(args: AttachInstancesCommandInput, options?: __HttpHandlerOptions): Promise<AttachInstancesCommandOutput>;
     attachInstances(args: AttachInstancesCommandInput, cb: (err: any, data?: AttachInstancesCommandOutput) => void): void;
     attachInstances(args: AttachInstancesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AttachInstancesCommandOutput) => void): void;
     /**
-     * @public
-     * <note>
-     *             <p>This API operation is superseded by <a>AttachTrafficSources</a>, which
-     *                 can attach multiple traffic sources types. We recommend using
-     *                     <code>AttachTrafficSources</code> to simplify how you manage traffic sources.
-     *                 However, we continue to support <code>AttachLoadBalancers</code>. You can use both
-     *                 the original <code>AttachLoadBalancers</code> API operation and
-     *                     <code>AttachTrafficSources</code> on the same Auto Scaling group.</p>
-     *          </note>
-     *          <p>Attaches one or more Classic Load Balancers to the specified Auto Scaling group. Amazon EC2 Auto Scaling registers the
-     *             running instances with these Classic Load Balancers.</p>
-     *          <p>To describe the load balancers for an Auto Scaling group, call the <a>DescribeLoadBalancers</a> API. To detach a load balancer from the Auto Scaling
-     *             group, call the <a>DetachLoadBalancers</a> API.</p>
-     *          <p>This operation is additive and does not detach existing Classic Load Balancers or
-     *             target groups from the Auto Scaling group.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/autoscaling-load-balancer.html">Use Elastic Load Balancing to
-     *                 distribute traffic across the instances in your Auto Scaling group</a> in the
-     *                 <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+     * @see {@link AttachLoadBalancersCommand}
      */
     attachLoadBalancers(args: AttachLoadBalancersCommandInput, options?: __HttpHandlerOptions): Promise<AttachLoadBalancersCommandOutput>;
     attachLoadBalancers(args: AttachLoadBalancersCommandInput, cb: (err: any, data?: AttachLoadBalancersCommandOutput) => void): void;
     attachLoadBalancers(args: AttachLoadBalancersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AttachLoadBalancersCommandOutput) => void): void;
     /**
-     * @public
-     * <note>
-     *             <p>This API operation is superseded by <a>AttachTrafficSources</a>, which
-     *                 can attach multiple traffic sources types. We recommend using
-     *                     <code>AttachTrafficSources</code> to simplify how you manage traffic sources.
-     *                 However, we continue to support <code>AttachLoadBalancerTargetGroups</code>. You can
-     *                 use both the original <code>AttachLoadBalancerTargetGroups</code> API operation and
-     *                     <code>AttachTrafficSources</code> on the same Auto Scaling group.</p>
-     *          </note>
-     *          <p>Attaches one or more target groups to the specified Auto Scaling group.</p>
-     *          <p>This operation is used with the following load balancer types: </p>
-     *          <ul>
-     *             <li>
-     *                <p>Application Load Balancer - Operates at the application layer (layer 7) and supports HTTP and
-     *                     HTTPS. </p>
-     *             </li>
-     *             <li>
-     *                <p>Network Load Balancer - Operates at the transport layer (layer 4) and supports TCP, TLS, and
-     *                     UDP. </p>
-     *             </li>
-     *             <li>
-     *                <p>Gateway Load Balancer - Operates at the network layer (layer 3).</p>
-     *             </li>
-     *          </ul>
-     *          <p>To describe the target groups for an Auto Scaling group, call the <a>DescribeLoadBalancerTargetGroups</a> API. To detach the target group from
-     *             the Auto Scaling group, call the <a>DetachLoadBalancerTargetGroups</a> API.</p>
-     *          <p>This operation is additive and does not detach existing target groups or Classic Load
-     *             Balancers from the Auto Scaling group.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/autoscaling-load-balancer.html">Use Elastic Load Balancing to
-     *                 distribute traffic across the instances in your Auto Scaling group</a> in the
-     *                 <i>Amazon EC2 Auto Scaling User Guide</i>. </p>
+     * @see {@link AttachLoadBalancerTargetGroupsCommand}
      */
     attachLoadBalancerTargetGroups(args: AttachLoadBalancerTargetGroupsCommandInput, options?: __HttpHandlerOptions): Promise<AttachLoadBalancerTargetGroupsCommandOutput>;
     attachLoadBalancerTargetGroups(args: AttachLoadBalancerTargetGroupsCommandInput, cb: (err: any, data?: AttachLoadBalancerTargetGroupsCommandOutput) => void): void;
     attachLoadBalancerTargetGroups(args: AttachLoadBalancerTargetGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AttachLoadBalancerTargetGroupsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Attaches one or more traffic sources to the specified Auto Scaling group.</p>
-     *          <p>You can use any of the following as traffic sources for an Auto Scaling group:</p>
-     *          <ul>
-     *             <li>
-     *                <p>Application Load Balancer</p>
-     *             </li>
-     *             <li>
-     *                <p>Classic Load Balancer</p>
-     *             </li>
-     *             <li>
-     *                <p>Gateway Load Balancer</p>
-     *             </li>
-     *             <li>
-     *                <p>Network Load Balancer</p>
-     *             </li>
-     *             <li>
-     *                <p>VPC Lattice</p>
-     *             </li>
-     *          </ul>
-     *          <p>This operation is additive and does not detach existing traffic sources from the Auto Scaling
-     *             group. </p>
-     *          <p>After the operation completes, use the <a>DescribeTrafficSources</a> API to
-     *             return details about the state of the attachments between traffic sources and your Auto Scaling
-     *             group. To detach a traffic source from the Auto Scaling group, call the <a>DetachTrafficSources</a> API.</p>
+     * @see {@link AttachTrafficSourcesCommand}
      */
     attachTrafficSources(args: AttachTrafficSourcesCommandInput, options?: __HttpHandlerOptions): Promise<AttachTrafficSourcesCommandOutput>;
     attachTrafficSources(args: AttachTrafficSourcesCommandInput, cb: (err: any, data?: AttachTrafficSourcesCommandOutput) => void): void;
     attachTrafficSources(args: AttachTrafficSourcesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AttachTrafficSourcesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes one or more scheduled actions for the specified Auto Scaling group.</p>
+     * @see {@link BatchDeleteScheduledActionCommand}
      */
     batchDeleteScheduledAction(args: BatchDeleteScheduledActionCommandInput, options?: __HttpHandlerOptions): Promise<BatchDeleteScheduledActionCommandOutput>;
     batchDeleteScheduledAction(args: BatchDeleteScheduledActionCommandInput, cb: (err: any, data?: BatchDeleteScheduledActionCommandOutput) => void): void;
     batchDeleteScheduledAction(args: BatchDeleteScheduledActionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchDeleteScheduledActionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates or updates one or more scheduled scaling actions for an Auto Scaling group.</p>
+     * @see {@link BatchPutScheduledUpdateGroupActionCommand}
      */
     batchPutScheduledUpdateGroupAction(args: BatchPutScheduledUpdateGroupActionCommandInput, options?: __HttpHandlerOptions): Promise<BatchPutScheduledUpdateGroupActionCommandOutput>;
     batchPutScheduledUpdateGroupAction(args: BatchPutScheduledUpdateGroupActionCommandInput, cb: (err: any, data?: BatchPutScheduledUpdateGroupActionCommandOutput) => void): void;
     batchPutScheduledUpdateGroupAction(args: BatchPutScheduledUpdateGroupActionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: BatchPutScheduledUpdateGroupActionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Cancels an instance refresh or rollback that is in progress. If an instance refresh or
-     *             rollback is not in progress, an <code>ActiveInstanceRefreshNotFound</code> error
-     *             occurs.</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>When you cancel an instance refresh, this does not roll back any changes that it made.
-     *             Use the <a>RollbackInstanceRefresh</a> API to roll back instead.</p>
+     * @see {@link CancelInstanceRefreshCommand}
      */
     cancelInstanceRefresh(args: CancelInstanceRefreshCommandInput, options?: __HttpHandlerOptions): Promise<CancelInstanceRefreshCommandOutput>;
     cancelInstanceRefresh(args: CancelInstanceRefreshCommandInput, cb: (err: any, data?: CancelInstanceRefreshCommandOutput) => void): void;
     cancelInstanceRefresh(args: CancelInstanceRefreshCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CancelInstanceRefreshCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Completes the lifecycle action for the specified token or instance with the specified
-     *             result.</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 launch template or launch configuration with a user data
-     *                     script that runs while an instance is in a wait state due to a lifecycle
-     *                     hook.</p>
-     *             </li>
-     *             <li>
-     *                <p>(Optional) Create a Lambda function and a rule that allows Amazon EventBridge to invoke
-     *                     your Lambda function when an instance is put into a wait state due to a
-     *                     lifecycle hook.</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>If you need more time, record the lifecycle action heartbeat to keep the
-     *                     instance in a wait state.</p>
-     *             </li>
-     *             <li>
-     *                <p>
-     *                   <b>If you finish before the timeout period ends, send a
-     *                         callback by using the <a>CompleteLifecycleAction</a> API
-     *                         call.</b>
-     *                </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>
+     * @see {@link CompleteLifecycleActionCommand}
      */
     completeLifecycleAction(args: CompleteLifecycleActionCommandInput, options?: __HttpHandlerOptions): Promise<CompleteLifecycleActionCommandOutput>;
     completeLifecycleAction(args: CompleteLifecycleActionCommandInput, cb: (err: any, data?: CompleteLifecycleActionCommandOutput) => void): void;
     completeLifecycleAction(args: CompleteLifecycleActionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CompleteLifecycleActionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>
-     *             <b>We strongly recommend using a launch template when calling this operation to ensure full functionality for Amazon EC2 Auto Scaling and Amazon EC2.</b>
-     *          </p>
-     *          <p>Creates an Auto Scaling group with the specified name and attributes. </p>
-     *          <p>If you exceed your maximum limit of Auto Scaling groups, the call fails. To query this limit,
-     *             call the <a>DescribeAccountLimits</a> API. For information about updating
-     *             this limit, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-quotas.html">Quotas for
-     *                 Amazon EC2 Auto Scaling</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
-     *          <p>For introductory exercises for creating an Auto Scaling group, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/GettingStartedTutorial.html">Getting started with
-     *                 Amazon EC2 Auto Scaling</a> and <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-register-lbs-with-asg.html">Tutorial: Set up a
-     *                 scaled and load-balanced application</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/AutoScalingGroup.html">Auto Scaling
-     *                 groups</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
-     *          <p>Every Auto Scaling group has three size properties (<code>DesiredCapacity</code>,
-     *                 <code>MaxSize</code>, and <code>MinSize</code>). Usually, you set these sizes based
-     *             on a specific number of instances. However, if you configure a mixed instances policy
-     *             that defines weights for the instance types, you must specify these sizes with the same
-     *             units that you use for weighting instances.</p>
+     * @see {@link CreateAutoScalingGroupCommand}
      */
     createAutoScalingGroup(args: CreateAutoScalingGroupCommandInput, options?: __HttpHandlerOptions): Promise<CreateAutoScalingGroupCommandOutput>;
     createAutoScalingGroup(args: CreateAutoScalingGroupCommandInput, cb: (err: any, data?: CreateAutoScalingGroupCommandOutput) => void): void;
     createAutoScalingGroup(args: CreateAutoScalingGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateAutoScalingGroupCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates a launch configuration.</p>
-     *          <p>If you exceed your maximum limit of launch configurations, the call fails. To query
-     *             this limit, call the <a>DescribeAccountLimits</a> API. For information about
-     *             updating this limit, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-quotas.html">Quotas for
-     *                 Amazon EC2 Auto Scaling</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/LaunchConfiguration.html">Launch
-     *                 configurations</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
-     *          <note>
-     *             <p>Amazon EC2 Auto Scaling configures instances launched as part of an Auto Scaling group using either a
-     *                 launch template or a launch configuration. We strongly recommend that you do not use
-     *                 launch configurations. They do not provide full functionality for Amazon EC2 Auto Scaling or Amazon EC2.
-     *                 For information about using launch templates, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/launch-templates.html">Launch templates</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
-     *          </note>
+     * @see {@link CreateLaunchConfigurationCommand}
      */
     createLaunchConfiguration(args: CreateLaunchConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<CreateLaunchConfigurationCommandOutput>;
     createLaunchConfiguration(args: CreateLaunchConfigurationCommandInput, cb: (err: any, data?: CreateLaunchConfigurationCommandOutput) => void): void;
     createLaunchConfiguration(args: CreateLaunchConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateLaunchConfigurationCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates or updates tags for the specified Auto Scaling group.</p>
-     *          <p>When you specify a tag with a key that already exists, the operation overwrites the
-     *             previous tag definition, and you do not get an error message.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-tagging.html">Tag Auto Scaling groups and
-     *                 instances</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+     * @see {@link CreateOrUpdateTagsCommand}
      */
     createOrUpdateTags(args: CreateOrUpdateTagsCommandInput, options?: __HttpHandlerOptions): Promise<CreateOrUpdateTagsCommandOutput>;
     createOrUpdateTags(args: CreateOrUpdateTagsCommandInput, cb: (err: any, data?: CreateOrUpdateTagsCommandOutput) => void): void;
     createOrUpdateTags(args: CreateOrUpdateTagsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateOrUpdateTagsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the specified Auto Scaling group.</p>
-     *          <p>If the group has instances or scaling activities in progress, you must specify the
-     *             option to force the deletion in order for it to succeed. The force delete operation will
-     *             also terminate the EC2 instances. If the group has a warm pool, the force delete option
-     *             also deletes the warm pool.</p>
-     *          <p>To remove instances from the Auto Scaling group before deleting it, call the <a>DetachInstances</a> API with the list of instances and the option to
-     *             decrement the desired capacity. This ensures that Amazon EC2 Auto Scaling does not launch replacement
-     *             instances.</p>
-     *          <p>To terminate all instances before deleting the Auto Scaling group, call the <a>UpdateAutoScalingGroup</a> API and set the minimum size and desired capacity
-     *             of the Auto Scaling group to
-     *             zero.</p>
-     *          <p>If the group has scaling policies, deleting the group deletes the policies, the
-     *             underlying alarm actions, and any alarm that no longer has an associated action.</p>
-     *          <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-process-shutdown.html">Delete your Auto Scaling
-     *                 infrastructure</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+     * @see {@link DeleteAutoScalingGroupCommand}
      */
     deleteAutoScalingGroup(args: DeleteAutoScalingGroupCommandInput, options?: __HttpHandlerOptions): Promise<DeleteAutoScalingGroupCommandOutput>;
     deleteAutoScalingGroup(args: DeleteAutoScalingGroupCommandInput, cb: (err: any, data?: DeleteAutoScalingGroupCommandOutput) => void): void;
     deleteAutoScalingGroup(args: DeleteAutoScalingGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteAutoScalingGroupCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DeleteLaunchConfigurationCommand}
      */
     deleteLaunchConfiguration(args: DeleteLaunchConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteLaunchConfigurationCommandOutput>;
     deleteLaunchConfiguration(args: DeleteLaunchConfigurationCommandInput, cb: (err: any, data?: DeleteLaunchConfigurationCommandOutput) => void): void;
     deleteLaunchConfiguration(args: DeleteLaunchConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteLaunchConfigurationCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DeleteLifecycleHookCommand}
      */
     deleteLifecycleHook(args: DeleteLifecycleHookCommandInput, options?: __HttpHandlerOptions): Promise<DeleteLifecycleHookCommandOutput>;
     deleteLifecycleHook(args: DeleteLifecycleHookCommandInput, cb: (err: any, data?: DeleteLifecycleHookCommandOutput) => void): void;
     deleteLifecycleHook(args: DeleteLifecycleHookCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteLifecycleHookCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the specified notification.</p>
+     * @see {@link DeleteNotificationConfigurationCommand}
      */
     deleteNotificationConfiguration(args: DeleteNotificationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteNotificationConfigurationCommandOutput>;
     deleteNotificationConfiguration(args: DeleteNotificationConfigurationCommandInput, cb: (err: any, data?: DeleteNotificationConfigurationCommandOutput) => void): void;
     deleteNotificationConfiguration(args: DeleteNotificationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteNotificationConfigurationCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DeletePolicyCommand}
      */
     deletePolicy(args: DeletePolicyCommandInput, options?: __HttpHandlerOptions): Promise<DeletePolicyCommandOutput>;
     deletePolicy(args: DeletePolicyCommandInput, cb: (err: any, data?: DeletePolicyCommandOutput) => void): void;
     deletePolicy(args: DeletePolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeletePolicyCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the specified scheduled action.</p>
+     * @see {@link DeleteScheduledActionCommand}
      */
     deleteScheduledAction(args: DeleteScheduledActionCommandInput, options?: __HttpHandlerOptions): Promise<DeleteScheduledActionCommandOutput>;
     deleteScheduledAction(args: DeleteScheduledActionCommandInput, cb: (err: any, data?: DeleteScheduledActionCommandOutput) => void): void;
     deleteScheduledAction(args: DeleteScheduledActionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteScheduledActionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Deletes the specified tags.</p>
+     * @see {@link DeleteTagsCommand}
      */
     deleteTags(args: DeleteTagsCommandInput, options?: __HttpHandlerOptions): Promise<DeleteTagsCommandOutput>;
     deleteTags(args: DeleteTagsCommandInput, cb: (err: any, data?: DeleteTagsCommandOutput) => void): void;
     deleteTags(args: DeleteTagsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteTagsCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DeleteWarmPoolCommand}
      */
     deleteWarmPool(args: DeleteWarmPoolCommandInput, options?: __HttpHandlerOptions): Promise<DeleteWarmPoolCommandOutput>;
     deleteWarmPool(args: DeleteWarmPoolCommandInput, cb: (err: any, data?: DeleteWarmPoolCommandOutput) => void): void;
     deleteWarmPool(args: DeleteWarmPoolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteWarmPoolCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Describes the current Amazon EC2 Auto Scaling resource quotas for your account.</p>
-     *          <p>When you establish an Amazon Web Services 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/ec2-auto-scaling-quotas.html">Quotas for
-     *                 Amazon EC2 Auto Scaling</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+     * @see {@link DescribeAccountLimitsCommand}
      */
     describeAccountLimits(args: DescribeAccountLimitsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeAccountLimitsCommandOutput>;
     describeAccountLimits(args: DescribeAccountLimitsCommandInput, cb: (err: any, data?: DescribeAccountLimitsCommandOutput) => void): void;
     describeAccountLimits(args: DescribeAccountLimitsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeAccountLimitsCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DescribeAdjustmentTypesCommand}
      */
     describeAdjustmentTypes(args: DescribeAdjustmentTypesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeAdjustmentTypesCommandOutput>;
     describeAdjustmentTypes(args: DescribeAdjustmentTypesCommandInput, cb: (err: any, data?: DescribeAdjustmentTypesCommandOutput) => void): void;
     describeAdjustmentTypes(args: DescribeAdjustmentTypesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeAdjustmentTypesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets information about the Auto Scaling groups in the account and Region.</p>
-     *          <p>If you specify Auto Scaling group names, the output includes information for only the
-     *             specified Auto Scaling groups. If you specify filters, the output includes information for only
-     *             those Auto Scaling groups that meet the filter criteria. If you do not specify group names or
-     *             filters, the output includes information for all Auto Scaling groups. </p>
-     *          <p>This operation also 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>
+     * @see {@link DescribeAutoScalingGroupsCommand}
      */
     describeAutoScalingGroups(args: DescribeAutoScalingGroupsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeAutoScalingGroupsCommandOutput>;
     describeAutoScalingGroups(args: DescribeAutoScalingGroupsCommandInput, cb: (err: any, data?: DescribeAutoScalingGroupsCommandOutput) => void): void;
     describeAutoScalingGroups(args: DescribeAutoScalingGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeAutoScalingGroupsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets information about the Auto Scaling instances in the account and Region.</p>
+     * @see {@link DescribeAutoScalingInstancesCommand}
      */
     describeAutoScalingInstances(args: DescribeAutoScalingInstancesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeAutoScalingInstancesCommandOutput>;
     describeAutoScalingInstances(args: DescribeAutoScalingInstancesCommandInput, cb: (err: any, data?: DescribeAutoScalingInstancesCommandOutput) => void): void;
     describeAutoScalingInstances(args: DescribeAutoScalingInstancesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeAutoScalingInstancesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Describes the notification types that are supported by Amazon EC2 Auto Scaling.</p>
+     * @see {@link DescribeAutoScalingNotificationTypesCommand}
      */
     describeAutoScalingNotificationTypes(args: DescribeAutoScalingNotificationTypesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeAutoScalingNotificationTypesCommandOutput>;
     describeAutoScalingNotificationTypes(args: DescribeAutoScalingNotificationTypesCommandInput, cb: (err: any, data?: DescribeAutoScalingNotificationTypesCommandOutput) => void): void;
     describeAutoScalingNotificationTypes(args: DescribeAutoScalingNotificationTypesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeAutoScalingNotificationTypesCommandOutput) => void): void;
     /**
-     * @public
-     * <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, Amazon EC2 Auto Scaling returns information
-     *             about the instance refreshes you previously initiated, including their status, start
-     *             time, 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. If a rollback
-     *             is initiated while an instance refresh is in progress, Amazon EC2 Auto Scaling also returns information
-     *             about the rollback of the instance refresh.</p>
+     * @see {@link DescribeInstanceRefreshesCommand}
      */
     describeInstanceRefreshes(args: DescribeInstanceRefreshesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeInstanceRefreshesCommandOutput>;
     describeInstanceRefreshes(args: DescribeInstanceRefreshesCommandInput, cb: (err: any, data?: DescribeInstanceRefreshesCommandOutput) => void): void;
     describeInstanceRefreshes(args: DescribeInstanceRefreshesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeInstanceRefreshesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets information about the launch configurations in the account and Region.</p>
+     * @see {@link DescribeLaunchConfigurationsCommand}
      */
     describeLaunchConfigurations(args: DescribeLaunchConfigurationsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeLaunchConfigurationsCommandOutput>;
     describeLaunchConfigurations(args: DescribeLaunchConfigurationsCommandInput, cb: (err: any, data?: DescribeLaunchConfigurationsCommandOutput) => void): void;
     describeLaunchConfigurations(args: DescribeLaunchConfigurationsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeLaunchConfigurationsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets information about the lifecycle hooks for the specified Auto Scaling group.</p>
+     * @see {@link DescribeLifecycleHooksCommand}
      */
     describeLifecycleHooks(args: DescribeLifecycleHooksCommandInput, options?: __HttpHandlerOptions): Promise<DescribeLifecycleHooksCommandOutput>;
     describeLifecycleHooks(args: DescribeLifecycleHooksCommandInput, cb: (err: any, data?: DescribeLifecycleHooksCommandOutput) => void): void;
     describeLifecycleHooks(args: DescribeLifecycleHooksCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeLifecycleHooksCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DescribeLifecycleHookTypesCommand}
      */
     describeLifecycleHookTypes(args: DescribeLifecycleHookTypesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeLifecycleHookTypesCommandOutput>;
     describeLifecycleHookTypes(args: DescribeLifecycleHookTypesCommandInput, cb: (err: any, data?: DescribeLifecycleHookTypesCommandOutput) => void): void;
     describeLifecycleHookTypes(args: DescribeLifecycleHookTypesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeLifecycleHookTypesCommandOutput) => void): void;
     /**
-     * @public
-     * <note>
-     *             <p>This API operation is superseded by <a>DescribeTrafficSources</a>,
-     *                 which can describe multiple traffic sources types. We recommend using
-     *                     <code>DescribeTrafficSources</code> to simplify how you manage traffic sources.
-     *                 However, we continue to support <code>DescribeLoadBalancers</code>. You can use both
-     *                 the original <code>DescribeLoadBalancers</code> API operation and
-     *                     <code>DescribeTrafficSources</code> on the same Auto Scaling group.</p>
-     *          </note>
-     *          <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 attachment status of the load balancer, 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">Use Elastic Load Balancing to
-     *                 distribute traffic across the instances in your Auto Scaling group</a> in the
-     *                 <i>Amazon EC2 Auto Scaling User Guide</i>. </p>
+     * @see {@link DescribeLoadBalancersCommand}
      */
     describeLoadBalancers(args: DescribeLoadBalancersCommandInput, options?: __HttpHandlerOptions): Promise<DescribeLoadBalancersCommandOutput>;
     describeLoadBalancers(args: DescribeLoadBalancersCommandInput, cb: (err: any, data?: DescribeLoadBalancersCommandOutput) => void): void;
     describeLoadBalancers(args: DescribeLoadBalancersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeLoadBalancersCommandOutput) => void): void;
     /**
-     * @public
-     * <note>
-     *             <p>This API operation is superseded by <a>DescribeTrafficSources</a>,
-     *                 which can describe multiple traffic sources types. We recommend using
-     *                     <code>DetachTrafficSources</code> to simplify how you manage traffic sources.
-     *                 However, we continue to support <code>DescribeLoadBalancerTargetGroups</code>. You
-     *                 can use both the original <code>DescribeLoadBalancerTargetGroups</code> API
-     *                 operation and <code>DescribeTrafficSources</code> on the same Auto Scaling group.</p>
-     *          </note>
-     *          <p>Gets information about the Elastic Load Balancing target groups for the specified Auto Scaling group.</p>
-     *          <p>To determine the attachment status of the target group, 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">Use Elastic Load Balancing to
-     *                 distribute traffic across the instances in your Auto Scaling group</a> in the
-     *                 <i>Amazon EC2 Auto Scaling User Guide</i>. </p>
-     *          <note>
-     *             <p>You can use this operation to describe target groups that were attached by using
-     *                     <a>AttachLoadBalancerTargetGroups</a>, but not for target groups that
-     *                 were attached by using <a>AttachTrafficSources</a>.</p>
-     *          </note>
+     * @see {@link DescribeLoadBalancerTargetGroupsCommand}
      */
     describeLoadBalancerTargetGroups(args: DescribeLoadBalancerTargetGroupsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeLoadBalancerTargetGroupsCommandOutput>;
     describeLoadBalancerTargetGroups(args: DescribeLoadBalancerTargetGroupsCommandInput, cb: (err: any, data?: DescribeLoadBalancerTargetGroupsCommandOutput) => void): void;
     describeLoadBalancerTargetGroups(args: DescribeLoadBalancerTargetGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeLoadBalancerTargetGroupsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Describes the available CloudWatch metrics for Amazon EC2 Auto Scaling.</p>
+     * @see {@link DescribeMetricCollectionTypesCommand}
      */
     describeMetricCollectionTypes(args: DescribeMetricCollectionTypesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeMetricCollectionTypesCommandOutput>;
     describeMetricCollectionTypes(args: DescribeMetricCollectionTypesCommandInput, cb: (err: any, data?: DescribeMetricCollectionTypesCommandOutput) => void): void;
     describeMetricCollectionTypes(args: DescribeMetricCollectionTypesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeMetricCollectionTypesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets information about the Amazon SNS notifications that are configured for one or more
-     *             Auto Scaling groups.</p>
+     * @see {@link DescribeNotificationConfigurationsCommand}
      */
     describeNotificationConfigurations(args: DescribeNotificationConfigurationsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeNotificationConfigurationsCommandOutput>;
     describeNotificationConfigurations(args: DescribeNotificationConfigurationsCommandInput, cb: (err: any, data?: DescribeNotificationConfigurationsCommandOutput) => void): void;
     describeNotificationConfigurations(args: DescribeNotificationConfigurationsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeNotificationConfigurationsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets information about the scaling policies in the account and Region.</p>
+     * @see {@link DescribePoliciesCommand}
      */
     describePolicies(args: DescribePoliciesCommandInput, options?: __HttpHandlerOptions): Promise<DescribePoliciesCommandOutput>;
     describePolicies(args: DescribePoliciesCommandInput, cb: (err: any, data?: DescribePoliciesCommandOutput) => void): void;
     describePolicies(args: DescribePoliciesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribePoliciesCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DescribeScalingActivitiesCommand}
      */
     describeScalingActivities(args: DescribeScalingActivitiesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeScalingActivitiesCommandOutput>;
     describeScalingActivities(args: DescribeScalingActivitiesCommandInput, cb: (err: any, data?: DescribeScalingActivitiesCommandOutput) => void): void;
     describeScalingActivities(args: DescribeScalingActivitiesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeScalingActivitiesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Describes the scaling process types for use with the <a>ResumeProcesses</a>
-     *             and <a>SuspendProcesses</a> APIs.</p>
+     * @see {@link DescribeScalingProcessTypesCommand}
      */
     describeScalingProcessTypes(args: DescribeScalingProcessTypesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeScalingProcessTypesCommandOutput>;
     describeScalingProcessTypes(args: DescribeScalingProcessTypesCommandInput, cb: (err: any, data?: DescribeScalingProcessTypesCommandOutput) => void): void;
     describeScalingProcessTypes(args: DescribeScalingProcessTypesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeScalingProcessTypesCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DescribeScheduledActionsCommand}
      */
     describeScheduledActions(args: DescribeScheduledActionsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeScheduledActionsCommandOutput>;
     describeScheduledActions(args: DescribeScheduledActionsCommandInput, cb: (err: any, data?: DescribeScheduledActionsCommandOutput) => void): void;
     describeScheduledActions(args: DescribeScheduledActionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeScheduledActionsCommandOutput) => void): void;
     /**
-     * @public
-     * <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/ec2-auto-scaling-tagging.html">Tag Auto Scaling groups and
-     *                 instances</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+     * @see {@link DescribeTagsCommand}
      */
     describeTags(args: DescribeTagsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTagsCommandOutput>;
     describeTags(args: DescribeTagsCommandInput, cb: (err: any, data?: DescribeTagsCommandOutput) => void): void;
     describeTags(args: DescribeTagsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeTagsCommandOutput) => void): void;
     /**
-     * @public
-     * <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/ec2-auto-scaling-termination-policies.html">Work with
-     *                 Amazon EC2 Auto Scaling termination policies</a> in the
-     *             <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+     * @see {@link DescribeTerminationPolicyTypesCommand}
      */
     describeTerminationPolicyTypes(args: DescribeTerminationPolicyTypesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTerminationPolicyTypesCommandOutput>;
     describeTerminationPolicyTypes(args: DescribeTerminationPolicyTypesCommandInput, cb: (err: any, data?: DescribeTerminationPolicyTypesCommandOutput) => void): void;
     describeTerminationPolicyTypes(args: DescribeTerminationPolicyTypesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeTerminationPolicyTypesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Gets information about the traffic sources for the specified Auto Scaling group.</p>
-     *          <p>You can optionally provide a traffic source type. If you provide a traffic source
-     *             type, then the results only include that traffic source type.</p>
-     *          <p>If you do not provide a traffic source type, then the results include all the traffic
-     *             sources for the specified Auto Scaling group. </p>
+     * @see {@link DescribeTrafficSourcesCommand}
      */
     describeTrafficSources(args: DescribeTrafficSourcesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTrafficSourcesCommandOutput>;
     describeTrafficSources(args: DescribeTrafficSourcesCommandInput, cb: (err: any, data?: DescribeTrafficSourcesCommandOutput) => void): void;
     describeTrafficSources(args: DescribeTrafficSourcesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeTrafficSourcesCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DescribeWarmPoolCommand}
      */
     describeWarmPool(args: DescribeWarmPoolCommandInput, options?: __HttpHandlerOptions): Promise<DescribeWarmPoolCommandOutput>;
     describeWarmPool(args: DescribeWarmPoolCommandInput, cb: (err: any, data?: DescribeWarmPoolCommandOutput) => void): void;
     describeWarmPool(args: DescribeWarmPoolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeWarmPoolCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link DetachInstancesCommand}
      */
     detachInstances(args: DetachInstancesCommandInput, options?: __HttpHandlerOptions): Promise<DetachInstancesCommandOutput>;
     detachInstances(args: DetachInstancesCommandInput, cb: (err: any, data?: DetachInstancesCommandOutput) => void): void;
     detachInstances(args: DetachInstancesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DetachInstancesCommandOutput) => void): void;
     /**
-     * @public
-     * <note>
-     *             <p>This API operation is superseded by <a>DetachTrafficSources</a>, which
-     *                 can detach multiple traffic sources types. We recommend using
-     *                     <code>DetachTrafficSources</code> to simplify how you manage traffic sources.
-     *                 However, we continue to support <code>DetachLoadBalancers</code>. You can use both
-     *                 the original <code>DetachLoadBalancers</code> API operation and
-     *                     <code>DetachTrafficSources</code> on the same Auto Scaling group.</p>
-     *          </note>
-     *          <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>
+     * @see {@link DetachLoadBalancersCommand}
      */
     detachLoadBalancers(args: DetachLoadBalancersCommandInput, options?: __HttpHandlerOptions): Promise<DetachLoadBalancersCommandOutput>;
     detachLoadBalancers(args: DetachLoadBalancersCommandInput, cb: (err: any, data?: DetachLoadBalancersCommandOutput) => void): void;
     detachLoadBalancers(args: DetachLoadBalancersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DetachLoadBalancersCommandOutput) => void): void;
     /**
-     * @public
-     * <note>
-     *             <p>This API operation is superseded by <a>DetachTrafficSources</a>, which
-     *                 can detach multiple traffic sources types. We recommend using
-     *                     <code>DetachTrafficSources</code> to simplify how you manage traffic sources.
-     *                 However, we continue to support <code>DetachLoadBalancerTargetGroups</code>. You can
-     *                 use both the original <code>DetachLoadBalancerTargetGroups</code> API operation and
-     *                     <code>DetachTrafficSources</code> on the same Auto Scaling group.</p>
-     *          </note>
-     *          <p>Detaches one or more target groups from the specified Auto Scaling group.</p>
-     *          <p>When you detach a target group, 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 target group using the <a>DescribeLoadBalancerTargetGroups</a> API call. The instances remain
-     *             running.</p>
-     *          <note>
-     *             <p>You can use this operation to detach target groups that were attached by using
-     *                     <a>AttachLoadBalancerTargetGroups</a>, but not for target groups that
-     *                 were attached by using <a>AttachTrafficSources</a>.</p>
-     *          </note>
+     * @see {@link DetachLoadBalancerTargetGroupsCommand}
      */
     detachLoadBalancerTargetGroups(args: DetachLoadBalancerTargetGroupsCommandInput, options?: __HttpHandlerOptions): Promise<DetachLoadBalancerTargetGroupsCommandOutput>;
     detachLoadBalancerTargetGroups(args: DetachLoadBalancerTargetGroupsCommandInput, cb: (err: any, data?: DetachLoadBalancerTargetGroupsCommandOutput) => void): void;
     detachLoadBalancerTargetGroups(args: DetachLoadBalancerTargetGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DetachLoadBalancerTargetGroupsCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Detaches one or more traffic sources from the specified Auto Scaling group.</p>
-     *          <p>When you detach a taffic, 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 traffic source using the <a>DescribeTrafficSources</a> API call. The instances continue to run.</p>
+     * @see {@link DetachTrafficSourcesCommand}
      */
     detachTrafficSources(args: DetachTrafficSourcesCommandInput, options?: __HttpHandlerOptions): Promise<DetachTrafficSourcesCommandOutput>;
     detachTrafficSources(args: DetachTrafficSourcesCommandInput, cb: (err: any, data?: DetachTrafficSourcesCommandOutput) => void): void;
     detachTrafficSources(args: DetachTrafficSourcesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DetachTrafficSourcesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Disables group metrics collection for the specified Auto Scaling group.</p>
+     * @see {@link DisableMetricsCollectionCommand}
      */
     disableMetricsCollection(args: DisableMetricsCollectionCommandInput, options?: __HttpHandlerOptions): Promise<DisableMetricsCollectionCommandOutput>;
     disableMetricsCollection(args: DisableMetricsCollectionCommandInput, cb: (err: any, data?: DisableMetricsCollectionCommandOutput) => void): void;
     disableMetricsCollection(args: DisableMetricsCollectionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DisableMetricsCollectionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Enables group metrics collection for the specified Auto Scaling group.</p>
-     *          <p>You can use these metrics to track changes in an Auto Scaling group and to set alarms on
-     *             threshold values. You can view group metrics using the Amazon EC2 Auto Scaling console or the CloudWatch
-     *             console. For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-cloudwatch-monitoring.html">Monitor
-     *                 CloudWatch metrics for your Auto Scaling groups and instances</a> in the
-     *                 <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+     * @see {@link EnableMetricsCollectionCommand}
      */
     enableMetricsCollection(args: EnableMetricsCollectionCommandInput, options?: __HttpHandlerOptions): Promise<EnableMetricsCollectionCommandOutput>;
     enableMetricsCollection(args: EnableMetricsCollectionCommandInput, cb: (err: any, data?: EnableMetricsCollectionCommandOutput) => void): void;
     enableMetricsCollection(args: EnableMetricsCollectionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: EnableMetricsCollectionCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link EnterStandbyCommand}
      */
     enterStandby(args: EnterStandbyCommandInput, options?: __HttpHandlerOptions): Promise<EnterStandbyCommandOutput>;
     enterStandby(args: EnterStandbyCommandInput, cb: (err: any, data?: EnterStandbyCommandOutput) => void): void;
     enterStandby(args: EnterStandbyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: EnterStandbyCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Executes the specified policy. This can be useful for testing the design of your
-     *             scaling policy.</p>
+     * @see {@link ExecutePolicyCommand}
      */
     executePolicy(args: ExecutePolicyCommandInput, options?: __HttpHandlerOptions): Promise<ExecutePolicyCommandOutput>;
     executePolicy(args: ExecutePolicyCommandInput, cb: (err: any, data?: ExecutePolicyCommandOutput) => void): void;
     executePolicy(args: ExecutePolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExecutePolicyCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link ExitStandbyCommand}
      */
     exitStandby(args: ExitStandbyCommandInput, options?: __HttpHandlerOptions): Promise<ExitStandbyCommandOutput>;
     exitStandby(args: ExitStandbyCommandInput, cb: (err: any, data?: ExitStandbyCommandOutput) => void): void;
     exitStandby(args: ExitStandbyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExitStandbyCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link GetPredictiveScalingForecastCommand}
      */
     getPredictiveScalingForecast(args: GetPredictiveScalingForecastCommandInput, options?: __HttpHandlerOptions): Promise<GetPredictiveScalingForecastCommandOutput>;
     getPredictiveScalingForecast(args: GetPredictiveScalingForecastCommandInput, cb: (err: any, data?: GetPredictiveScalingForecastCommandOutput) => void): void;
     getPredictiveScalingForecast(args: GetPredictiveScalingForecastCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetPredictiveScalingForecastCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Creates or updates a lifecycle hook for the specified Auto Scaling group.</p>
-     *          <p>Lifecycle hooks let you create solutions that are aware of events in the Auto Scaling instance
-     *             lifecycle, and then perform a custom action on instances when the corresponding
-     *             lifecycle event occurs.</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 launch template or launch configuration with a user data
-     *                     script that runs while an instance is in a wait state due to a lifecycle
-     *                     hook.</p>
-     *             </li>
-     *             <li>
-     *                <p>(Optional) Create a Lambda function and a rule that allows Amazon EventBridge to invoke
-     *                     your Lambda function when an instance is put into a wait state due to a
-     *                     lifecycle hook.</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 wait state using the <a>RecordLifecycleActionHeartbeat</a> API call.</p>
-     *             </li>
-     *             <li>
-     *                <p>If you finish before the timeout period ends, send a callback by 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>
+     * @see {@link PutLifecycleHookCommand}
      */
     putLifecycleHook(args: PutLifecycleHookCommandInput, options?: __HttpHandlerOptions): Promise<PutLifecycleHookCommandOutput>;
     putLifecycleHook(args: PutLifecycleHookCommandInput, cb: (err: any, data?: PutLifecycleHookCommandOutput) => void): void;
     putLifecycleHook(args: PutLifecycleHookCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutLifecycleHookCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link PutNotificationConfigurationCommand}
      */
     putNotificationConfiguration(args: PutNotificationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<PutNotificationConfigurationCommandOutput>;
     putNotificationConfiguration(args: PutNotificationConfigurationCommandInput, cb: (err: any, data?: PutNotificationConfigurationCommandOutput) => void): void;
     putNotificationConfiguration(args: PutNotificationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutNotificationConfigurationCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link PutScalingPolicyCommand}
      */
     putScalingPolicy(args: PutScalingPolicyCommandInput, options?: __HttpHandlerOptions): Promise<PutScalingPolicyCommandOutput>;
     putScalingPolicy(args: PutScalingPolicyCommandInput, cb: (err: any, data?: PutScalingPolicyCommandOutput) => void): void;
     putScalingPolicy(args: PutScalingPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutScalingPolicyCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
-     *          <p>If you try to schedule your action in the past, Amazon EC2 Auto Scaling returns an error
-     *             message.</p>
+     * @see {@link PutScheduledUpdateGroupActionCommand}
      */
     putScheduledUpdateGroupAction(args: PutScheduledUpdateGroupActionCommandInput, options?: __HttpHandlerOptions): Promise<PutScheduledUpdateGroupActionCommandOutput>;
     putScheduledUpdateGroupAction(args: PutScheduledUpdateGroupActionCommandInput, cb: (err: any, data?: PutScheduledUpdateGroupActionCommandOutput) => void): void;
     putScheduledUpdateGroupAction(args: PutScheduledUpdateGroupActionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutScheduledUpdateGroupActionCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link PutWarmPoolCommand}
      */
     putWarmPool(args: PutWarmPoolCommandInput, options?: __HttpHandlerOptions): Promise<PutWarmPoolCommandOutput>;
     putWarmPool(args: PutWarmPoolCommandInput, cb: (err: any, data?: PutWarmPoolCommandOutput) => void): void;
     putWarmPool(args: PutWarmPoolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutWarmPoolCommandOutput) => void): void;
     /**
-     * @public
-     * <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 launch template or launch configuration with a user data
-     *                     script that runs while an instance is in a wait state due to a lifecycle
-     *                     hook.</p>
-     *             </li>
-     *             <li>
-     *                <p>(Optional) Create a Lambda function and a rule that allows Amazon EventBridge to invoke
-     *                     your Lambda function when an instance is put into a wait state due to a
-     *                     lifecycle hook.</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 wait state.</b>
-     *                </p>
-     *             </li>
-     *             <li>
-     *                <p>If you finish before the timeout period ends, send a callback by 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>
+     * @see {@link RecordLifecycleActionHeartbeatCommand}
      */
     recordLifecycleActionHeartbeat(args: RecordLifecycleActionHeartbeatCommandInput, options?: __HttpHandlerOptions): Promise<RecordLifecycleActionHeartbeatCommandOutput>;
     recordLifecycleActionHeartbeat(args: RecordLifecycleActionHeartbeatCommandInput, cb: (err: any, data?: RecordLifecycleActionHeartbeatCommandOutput) => void): void;
     recordLifecycleActionHeartbeat(args: RecordLifecycleActionHeartbeatCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RecordLifecycleActionHeartbeatCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link ResumeProcessesCommand}
      */
     resumeProcesses(args: ResumeProcessesCommandInput, options?: __HttpHandlerOptions): Promise<ResumeProcessesCommandOutput>;
     resumeProcesses(args: ResumeProcessesCommandInput, cb: (err: any, data?: ResumeProcessesCommandOutput) => void): void;
     resumeProcesses(args: ResumeProcessesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ResumeProcessesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Cancels an instance refresh that is in progress and rolls back any changes that it
-     *             made. Amazon EC2 Auto Scaling replaces any instances that were replaced during the instance refresh.
-     *             This restores your Auto Scaling group to the configuration that it was using before the start of
-     *             the instance refresh. </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>A rollback is not supported in the following situations: </p>
-     *          <ul>
-     *             <li>
-     *                <p>There is no desired configuration specified for the instance refresh.</p>
-     *             </li>
-     *             <li>
-     *                <p>The Auto Scaling group has a launch template that uses an Amazon Web Services Systems Manager parameter instead
-     *                     of an AMI ID for the <code>ImageId</code> property.</p>
-     *             </li>
-     *             <li>
-     *                <p>The Auto Scaling group uses the launch template's <code>$Latest</code> or
-     *                         <code>$Default</code> version.</p>
-     *             </li>
-     *          </ul>
-     *          <p>When you receive a successful response from this operation, Amazon EC2 Auto Scaling immediately
-     *             begins replacing instances. You can check the status of this operation through the <a>DescribeInstanceRefreshes</a> API operation. </p>
+     * @see {@link RollbackInstanceRefreshCommand}
      */
     rollbackInstanceRefresh(args: RollbackInstanceRefreshCommandInput, options?: __HttpHandlerOptions): Promise<RollbackInstanceRefreshCommandOutput>;
     rollbackInstanceRefresh(args: RollbackInstanceRefreshCommandInput, cb: (err: any, data?: RollbackInstanceRefreshCommandOutput) => void): void;
     rollbackInstanceRefresh(args: RollbackInstanceRefreshCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RollbackInstanceRefreshCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link SetDesiredCapacityCommand}
      */
     setDesiredCapacity(args: SetDesiredCapacityCommandInput, options?: __HttpHandlerOptions): Promise<SetDesiredCapacityCommandOutput>;
     setDesiredCapacity(args: SetDesiredCapacityCommandInput, cb: (err: any, data?: SetDesiredCapacityCommandOutput) => void): void;
     setDesiredCapacity(args: SetDesiredCapacityCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SetDesiredCapacityCommandOutput) => void): void;
     /**
-     * @public
-     * <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>
+     * @see {@link SetInstanceHealthCommand}
      */
     setInstanceHealth(args: SetInstanceHealthCommandInput, options?: __HttpHandlerOptions): Promise<SetInstanceHealthCommandOutput>;
     setInstanceHealth(args: SetInstanceHealthCommandInput, cb: (err: any, data?: SetInstanceHealthCommandOutput) => void): void;
     setInstanceHealth(args: SetInstanceHealthCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SetInstanceHealthCommandOutput) => void): void;
     /**
-     * @public
-     * <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/ec2-auto-scaling-instance-protection.html">Using
-     *                 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>
+     * @see {@link SetInstanceProtectionCommand}
      */
     setInstanceProtection(args: SetInstanceProtectionCommandInput, options?: __HttpHandlerOptions): Promise<SetInstanceProtectionCommandOutput>;
     setInstanceProtection(args: SetInstanceProtectionCommandInput, cb: (err: any, data?: SetInstanceProtectionCommandOutput) => void): void;
     setInstanceProtection(args: SetInstanceProtectionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SetInstanceProtectionCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Starts an instance refresh. During an instance refresh, Amazon EC2 Auto Scaling performs a rolling
-     *             update of instances in an Auto Scaling group. Instances are terminated first and then replaced,
-     *             which temporarily reduces the capacity available within your Auto Scaling group.</p>
-     *          <p>This operation is part of the <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-instance-refresh.html">instance refresh
-     *                 feature</a> in Amazon EC2 Auto Scaling, which helps you update instances in your Auto Scaling group.
-     *             This feature is helpful, for example, when you have a new AMI or a new user data script.
-     *             You just need to create a new launch template that specifies the new AMI or user data
-     *             script. Then start an instance refresh to immediately begin the process of updating
-     *             instances in the group. </p>
-     *          <p>If successful, the request's response contains a unique ID that you can use to track
-     *             the progress of the instance refresh. To query its status, call the <a>DescribeInstanceRefreshes</a> API. To describe the instance refreshes that
-     *             have already run, call the <a>DescribeInstanceRefreshes</a> API. To cancel an
-     *             instance refresh that is in progress, use the <a>CancelInstanceRefresh</a>
-     *             API. </p>
-     *          <p>An instance refresh might fail for several reasons, such as EC2 launch failures,
-     *             misconfigured health checks, or not ignoring or allowing the termination of instances
-     *             that are in <code>Standby</code> state or protected from scale in. You can monitor for
-     *             failed EC2 launches using the scaling activities. To find the scaling activities, call
-     *             the <a>DescribeScalingActivities</a> API.</p>
-     *          <p>If you enable auto rollback, your Auto Scaling group will be rolled back automatically when
-     *             the instance refresh fails. You can enable this feature before starting an instance
-     *             refresh by specifying the <code>AutoRollback</code> property in the instance refresh
-     *             preferences. Otherwise, to roll back an instance refresh before it finishes, use the
-     *                 <a>RollbackInstanceRefresh</a> API. </p>
+     * @see {@link StartInstanceRefreshCommand}
      */
     startInstanceRefresh(args: StartInstanceRefreshCommandInput, options?: __HttpHandlerOptions): Promise<StartInstanceRefreshCommandOutput>;
     startInstanceRefresh(args: StartInstanceRefreshCommandInput, cb: (err: any, data?: StartInstanceRefreshCommandOutput) => void): void;
     startInstanceRefresh(args: StartInstanceRefreshCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartInstanceRefreshCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Suspends the specified auto scaling processes, or all processes, for the specified
-     *             Auto Scaling group.</p>
-     *          <p>If you suspend either the <code>Launch</code> or <code>Terminate</code> process types,
-     *             it can prevent other process types from functioning properly. For more information, see
-     *                 <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-suspend-resume-processes.html">Suspending and
-     *                 resuming scaling processes</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
-     *          <p>To resume processes that have been suspended, call the <a>ResumeProcesses</a> API.</p>
+     * @see {@link SuspendProcessesCommand}
      */
     suspendProcesses(args: SuspendProcessesCommandInput, options?: __HttpHandlerOptions): Promise<SuspendProcessesCommandOutput>;
     suspendProcesses(args: SuspendProcessesCommandInput, cb: (err: any, data?: SuspendProcessesCommandOutput) => void): void;
     suspendProcesses(args: SuspendProcessesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: SuspendProcessesCommandOutput) => void): void;
     /**
-     * @public
-     * <p>Terminates the specified instance and optionally adjusts the desired group size. This
-     *             operation cannot be called on instances in a warm pool.</p>
-     *          <p>This call simply makes a termination request. The instance is not terminated
-     *             immediately. When an instance is terminated, the instance status changes to
-     *                 <code>terminated</code>. You can't connect to or start an instance after you've
-     *             terminated it.</p>
-     *          <p>If you do not specify the option to decrement the desired capacity, Amazon EC2 Auto Scaling launches
-     *             instances to replace the ones that are terminated. </p>
-     *          <p>By default, Amazon EC2 Auto Scaling balances instances across all Availability Zones. If you
-     *             decrement the desired capacity, your Auto Scaling group can become unbalanced between
-     *             Availability Zones. Amazon EC2 Auto Scaling tries to rebalance the group, and rebalancing might
-     *             terminate instances in other zones. For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/auto-scaling-benefits.html#AutoScalingBehavior.InstanceUsage">Rebalancing activities</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+     * @see {@link TerminateInstanceInAutoScalingGroupCommand}
      */
     terminateInstanceInAutoScalingGroup(args: TerminateInstanceInAutoScalingGroupCommandInput, options?: __HttpHandlerOptions): Promise<TerminateInstanceInAutoScalingGroupCommandOutput>;
     terminateInstanceInAutoScalingGroup(args: TerminateInstanceInAutoScalingGroupCommandInput, cb: (err: any, data?: TerminateInstanceInAutoScalingGroupCommandOutput) => void): void;
     terminateInstanceInAutoScalingGroup(args: TerminateInstanceInAutoScalingGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TerminateInstanceInAutoScalingGroupCommandOutput) => void): void;
     /**
-     * @public
-     * <p>
-     *             <b>We strongly recommend that all Auto Scaling groups use launch templates to ensure full functionality for Amazon EC2 Auto Scaling and Amazon EC2.</b>
-     *          </p>
-     *          <p>Updates the configuration for the specified Auto Scaling group.</p>
-     *          <p>To update an Auto Scaling group, specify the name of the group and the property that you want
-     *             to change. Any properties that you don't specify are not changed by this update request.
-     *             The new settings take effect on any scaling activities after this call returns.
-     *             </p>
-     *          <p>If you associate a new launch configuration or template with an Auto Scaling group, all new
-     *             instances will get the updated configuration. Existing instances continue to run with
-     *             the configuration that they were originally launched with. When you update a group to
-     *             specify a mixed instances policy instead of a launch configuration or template, existing
-     *             instances may be replaced to match the new purchasing options that you specified in the
-     *             policy. For example, if the group currently has 100% On-Demand capacity and the policy
-     *             specifies 50% Spot capacity, this means that half of your instances will be gradually
-     *             terminated and relaunched as Spot Instances. When replacing instances, Amazon EC2 Auto Scaling launches
-     *             new instances before terminating the old ones, so that updating your group does not
-     *             compromise the performance or availability of your application.</p>
-     *          <p>Note the following about changing <code>DesiredCapacity</code>, <code>MaxSize</code>,
-     *             or <code>MinSize</code>:</p>
-     *          <ul>
-     *             <li>
-     *                <p>If a scale-in activity occurs as a result of a new
-     *                         <code>DesiredCapacity</code> value that is lower than the current size of
-     *                     the group, the Auto Scaling group uses its termination policy to determine which
-     *                     instances to terminate.</p>
-     *             </li>
-     *             <li>
-     *                <p>If you specify a new value for <code>MinSize</code> without specifying a value
-     *                     for <code>DesiredCapacity</code>, and the new <code>MinSize</code> is larger
-     *                     than the current size of the group, this sets the group's
-     *                         <code>DesiredCapacity</code> to the new <code>MinSize</code> value.</p>
-     *             </li>
-     *             <li>
-     *                <p>If you specify a new value for <code>MaxSize</code> without specifying a value
-     *                     for <code>DesiredCapacity</code>, and the new <code>MaxSize</code> is smaller
-     *                     than the current size of the group, this sets the group's
-     *                         <code>DesiredCapacity</code> to the new <code>MaxSize</code> value.</p>
-     *             </li>
-     *          </ul>
-     *          <p>To see which properties have been set, call the <a>DescribeAutoScalingGroups</a> API. To view the scaling policies for an Auto Scaling
-     *             group, call the <a>DescribePolicies</a> API. If the group has scaling
-     *             policies, you can update them by calling the <a>PutScalingPolicy</a>
-     *             API.</p>
+     * @see {@link UpdateAutoScalingGroupCommand}
      */
     updateAutoScalingGroup(args: UpdateAutoScalingGroupCommandInput, options?: __HttpHandlerOptions): Promise<UpdateAutoScalingGroupCommandOutput>;
     updateAutoScalingGroup(args: UpdateAutoScalingGroupCommandInput, cb: (err: any, data?: UpdateAutoScalingGroupCommandOutput) => void): void;
     updateAutoScalingGroup(args: UpdateAutoScalingGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateAutoScalingGroupCommandOutput) => void): void;
 }
+/**
+ * @public
+ * <fullname>Amazon EC2 Auto Scaling</fullname>
+ *          <p>Amazon EC2 Auto Scaling is designed to automatically launch and terminate EC2 instances
+ *             based on user-defined scaling policies, scheduled actions, and health checks.</p>
+ *          <p>For more information, see the <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/">Amazon EC2 Auto Scaling User Guide</a> and the <a href="https://docs.aws.amazon.com/autoscaling/ec2/APIReference/Welcome.html">Amazon EC2 Auto Scaling API Reference</a>.</p>
+ */
+export declare class AutoScaling extends AutoScalingClient implements AutoScaling {
+}