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

package/src/commands/SetInstanceHealthCommand.ts

@@ -1,97 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { SetInstanceHealthQuery } from "../models/models_0";
-import {
-  deserializeAws_querySetInstanceHealthCommand,
-  serializeAws_querySetInstanceHealthCommand,
-} from "../protocols/Aws_query";
-
-export interface SetInstanceHealthCommandInput extends SetInstanceHealthQuery {}
-export interface SetInstanceHealthCommandOutput extends __MetadataBearer {}
-
-/**
- * <p>Sets the health status of the specified instance.</p>
- *         <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/healthcheck.html">Health checks for Auto Scaling
- *                 instances</a> in the <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, SetInstanceHealthCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, SetInstanceHealthCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new SetInstanceHealthCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetInstanceHealthCommandInput} for command's `input` shape.
- * @see {@link SetInstanceHealthCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class SetInstanceHealthCommand extends $Command<
-  SetInstanceHealthCommandInput,
-  SetInstanceHealthCommandOutput,
-  AutoScalingClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SetInstanceHealthCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AutoScalingClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SetInstanceHealthCommandInput, SetInstanceHealthCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "AutoScalingClient";
-    const commandName = "SetInstanceHealthCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SetInstanceHealthQuery.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SetInstanceHealthCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySetInstanceHealthCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SetInstanceHealthCommandOutput> {
-    return deserializeAws_querySetInstanceHealthCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/SetInstanceProtectionCommand.ts

@@ -1,101 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { SetInstanceProtectionAnswer, SetInstanceProtectionQuery } from "../models/models_0";
-import {
-  deserializeAws_querySetInstanceProtectionCommand,
-  serializeAws_querySetInstanceProtectionCommand,
-} from "../protocols/Aws_query";
-
-export interface SetInstanceProtectionCommandInput extends SetInstanceProtectionQuery {}
-export interface SetInstanceProtectionCommandOutput extends SetInstanceProtectionAnswer, __MetadataBearer {}
-
-/**
- * <p>Updates the instance protection settings of the specified instances. This operation
- *             cannot be called on instances in a warm pool.</p>
- *         <p>For more information about preventing instances that are part of an Auto Scaling group from
- *             terminating on scale in, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-instance-termination.html#instance-protection">Instance scale-in protection</a> in the
- *             <i>Amazon EC2 Auto Scaling User Guide</i>.</p>
- *         <p>If you exceed your maximum limit of instance IDs, which is 50 per Auto Scaling group, the call
- *             fails.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, SetInstanceProtectionCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, SetInstanceProtectionCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new SetInstanceProtectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetInstanceProtectionCommandInput} for command's `input` shape.
- * @see {@link SetInstanceProtectionCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class SetInstanceProtectionCommand extends $Command<
-  SetInstanceProtectionCommandInput,
-  SetInstanceProtectionCommandOutput,
-  AutoScalingClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SetInstanceProtectionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AutoScalingClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SetInstanceProtectionCommandInput, SetInstanceProtectionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "AutoScalingClient";
-    const commandName = "SetInstanceProtectionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SetInstanceProtectionQuery.filterSensitiveLog,
-      outputFilterSensitiveLog: SetInstanceProtectionAnswer.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SetInstanceProtectionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySetInstanceProtectionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SetInstanceProtectionCommandOutput> {
-    return deserializeAws_querySetInstanceProtectionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/StartInstanceRefreshCommand.ts

@@ -1,109 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { StartInstanceRefreshAnswer, StartInstanceRefreshType } from "../models/models_0";
-import {
-  deserializeAws_queryStartInstanceRefreshCommand,
-  serializeAws_queryStartInstanceRefreshCommand,
-} from "../protocols/Aws_query";
-
-export interface StartInstanceRefreshCommandInput extends StartInstanceRefreshType {}
-export interface StartInstanceRefreshCommandOutput extends StartInstanceRefreshAnswer, __MetadataBearer {}
-
-/**
- * <p>Starts a new instance refresh operation. An instance refresh performs a rolling
- *             replacement of all or some instances in an Auto Scaling group. Each instance is 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 the call succeeds, it creates a new instance refresh request with a unique ID that
- *             you can use to track its progress. 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 operation in progress, use the <a>CancelInstanceRefresh</a>
- *             API. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, StartInstanceRefreshCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, StartInstanceRefreshCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new StartInstanceRefreshCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartInstanceRefreshCommandInput} for command's `input` shape.
- * @see {@link StartInstanceRefreshCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class StartInstanceRefreshCommand extends $Command<
-  StartInstanceRefreshCommandInput,
-  StartInstanceRefreshCommandOutput,
-  AutoScalingClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: StartInstanceRefreshCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AutoScalingClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<StartInstanceRefreshCommandInput, StartInstanceRefreshCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "AutoScalingClient";
-    const commandName = "StartInstanceRefreshCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: StartInstanceRefreshType.filterSensitiveLog,
-      outputFilterSensitiveLog: StartInstanceRefreshAnswer.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: StartInstanceRefreshCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryStartInstanceRefreshCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<StartInstanceRefreshCommandOutput> {
-    return deserializeAws_queryStartInstanceRefreshCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/SuspendProcessesCommand.ts

@@ -1,101 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { ScalingProcessQuery } from "../models/models_0";
-import {
-  deserializeAws_querySuspendProcessesCommand,
-  serializeAws_querySuspendProcessesCommand,
-} from "../protocols/Aws_query";
-
-export interface SuspendProcessesCommandInput extends ScalingProcessQuery {}
-export interface SuspendProcessesCommandOutput extends __MetadataBearer {}
-
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, SuspendProcessesCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, SuspendProcessesCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new SuspendProcessesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SuspendProcessesCommandInput} for command's `input` shape.
- * @see {@link SuspendProcessesCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class SuspendProcessesCommand extends $Command<
-  SuspendProcessesCommandInput,
-  SuspendProcessesCommandOutput,
-  AutoScalingClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SuspendProcessesCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AutoScalingClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SuspendProcessesCommandInput, SuspendProcessesCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "AutoScalingClient";
-    const commandName = "SuspendProcessesCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: ScalingProcessQuery.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SuspendProcessesCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySuspendProcessesCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SuspendProcessesCommandOutput> {
-    return deserializeAws_querySuspendProcessesCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/TerminateInstanceInAutoScalingGroupCommand.ts

@@ -1,112 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { ActivityType, TerminateInstanceInAutoScalingGroupType } from "../models/models_0";
-import {
-  deserializeAws_queryTerminateInstanceInAutoScalingGroupCommand,
-  serializeAws_queryTerminateInstanceInAutoScalingGroupCommand,
-} from "../protocols/Aws_query";
-
-export interface TerminateInstanceInAutoScalingGroupCommandInput extends TerminateInstanceInAutoScalingGroupType {}
-export interface TerminateInstanceInAutoScalingGroupCommandOutput extends ActivityType, __MetadataBearer {}
-
-/**
- * <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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, TerminateInstanceInAutoScalingGroupCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, TerminateInstanceInAutoScalingGroupCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new TerminateInstanceInAutoScalingGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TerminateInstanceInAutoScalingGroupCommandInput} for command's `input` shape.
- * @see {@link TerminateInstanceInAutoScalingGroupCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class TerminateInstanceInAutoScalingGroupCommand extends $Command<
-  TerminateInstanceInAutoScalingGroupCommandInput,
-  TerminateInstanceInAutoScalingGroupCommandOutput,
-  AutoScalingClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: TerminateInstanceInAutoScalingGroupCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AutoScalingClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<TerminateInstanceInAutoScalingGroupCommandInput, TerminateInstanceInAutoScalingGroupCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "AutoScalingClient";
-    const commandName = "TerminateInstanceInAutoScalingGroupCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: TerminateInstanceInAutoScalingGroupType.filterSensitiveLog,
-      outputFilterSensitiveLog: ActivityType.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: TerminateInstanceInAutoScalingGroupCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_queryTerminateInstanceInAutoScalingGroupCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<TerminateInstanceInAutoScalingGroupCommandOutput> {
-    return deserializeAws_queryTerminateInstanceInAutoScalingGroupCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/UpdateAutoScalingGroupCommand.ts

@@ -1,139 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { UpdateAutoScalingGroupType } from "../models/models_0";
-import {
-  deserializeAws_queryUpdateAutoScalingGroupCommand,
-  serializeAws_queryUpdateAutoScalingGroupCommand,
-} from "../protocols/Aws_query";
-
-export interface UpdateAutoScalingGroupCommandInput extends UpdateAutoScalingGroupType {}
-export interface UpdateAutoScalingGroupCommandOutput extends __MetadataBearer {}
-
-/**
- * <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 parameter that you want
- *             to change. Any parameters 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 parameters 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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, UpdateAutoScalingGroupCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, UpdateAutoScalingGroupCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new UpdateAutoScalingGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAutoScalingGroupCommandInput} for command's `input` shape.
- * @see {@link UpdateAutoScalingGroupCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class UpdateAutoScalingGroupCommand extends $Command<
-  UpdateAutoScalingGroupCommandInput,
-  UpdateAutoScalingGroupCommandOutput,
-  AutoScalingClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: UpdateAutoScalingGroupCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AutoScalingClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<UpdateAutoScalingGroupCommandInput, UpdateAutoScalingGroupCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "AutoScalingClient";
-    const commandName = "UpdateAutoScalingGroupCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: UpdateAutoScalingGroupType.filterSensitiveLog,
-      outputFilterSensitiveLog: (output: any) => output,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: UpdateAutoScalingGroupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryUpdateAutoScalingGroupCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<UpdateAutoScalingGroupCommandOutput> {
-    return deserializeAws_queryUpdateAutoScalingGroupCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}