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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { DescribePoliciesType, PoliciesType } from "../models/models_0";
+export interface DescribePoliciesCommandInput extends DescribePoliciesType {
+}
+export interface DescribePoliciesCommandOutput extends PoliciesType, __MetadataBearer {
+}
+/**
+ * <p>Gets information about the scaling policies in the account and Region.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, DescribePoliciesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, DescribePoliciesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new DescribePoliciesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribePoliciesCommandInput} for command's `input` shape.
+ * @see {@link DescribePoliciesCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribePoliciesCommand extends $Command<DescribePoliciesCommandInput, DescribePoliciesCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: DescribePoliciesCommandInput;
+    constructor(input: DescribePoliciesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePoliciesCommandInput, DescribePoliciesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
+import { DescribeTerminationPolicyTypesAnswer } from "../models/models_0";
+export interface DescribeTerminationPolicyTypesCommandInput {
+}
+export interface DescribeTerminationPolicyTypesCommandOutput extends DescribeTerminationPolicyTypesAnswer, __MetadataBearer {
+}
+/**
+ * <p>Describes the termination policies supported by Amazon EC2 Auto Scaling.</p>
+ *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html">Controlling which Auto Scaling
+ *                 instances terminate during scale in</a> in the
+ *                 <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { AutoScalingClient, DescribeTerminationPolicyTypesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
+ * // const { AutoScalingClient, DescribeTerminationPolicyTypesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
+ * const client = new AutoScalingClient(config);
+ * const command = new DescribeTerminationPolicyTypesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeTerminationPolicyTypesCommandInput} for command's `input` shape.
+ * @see {@link DescribeTerminationPolicyTypesCommandOutput} for command's `response` shape.
+ * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeTerminationPolicyTypesCommand extends $Command<DescribeTerminationPolicyTypesCommandInput, DescribeTerminationPolicyTypesCommandOutput, AutoScalingClientResolvedConfig> {
+    readonly input: DescribeTerminationPolicyTypesCommandInput;
+    constructor(input: DescribeTerminationPolicyTypesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AutoScalingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTerminationPolicyTypesCommandInput, DescribeTerminationPolicyTypesCommandOutput>;
+    private serialize;
+    private deserialize;
+}