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

package/commands/PutScalingPolicyCommand.ts

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

package/commands/PutScheduledUpdateGroupActionCommand.ts

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

package/commands/PutWarmPoolCommand.ts

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

package/commands/RecordLifecycleActionHeartbeatCommand.ts

@@ -1,134 +0,0 @@
-import { AutoScalingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../AutoScalingClient";
-import { RecordLifecycleActionHeartbeatAnswer, RecordLifecycleActionHeartbeatType } from "../models/models_0";
-import {
-  deserializeAws_queryRecordLifecycleActionHeartbeatCommand,
-  serializeAws_queryRecordLifecycleActionHeartbeatCommand,
-} from "../protocols/Aws_query";
-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,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface RecordLifecycleActionHeartbeatCommandInput extends RecordLifecycleActionHeartbeatType {}
-export interface RecordLifecycleActionHeartbeatCommandOutput
-  extends RecordLifecycleActionHeartbeatAnswer,
-    __MetadataBearer {}
-
-/**
- * <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 Lambda function and a rule that allows CloudWatch Events to
- *                     invoke your Lambda function when Amazon EC2 Auto Scaling launches or terminates
- *                     instances.</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 pending state.</b>
- *                 </p>
- *             </li>
- *             <li>
- *                 <p>If you finish before the timeout period ends, complete the lifecycle
- *                     action.</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>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AutoScalingClient, RecordLifecycleActionHeartbeatCommand } from "@aws-sdk/client-auto-scaling"; // ES Modules import
- * // const { AutoScalingClient, RecordLifecycleActionHeartbeatCommand } = require("@aws-sdk/client-auto-scaling"); // CommonJS import
- * const client = new AutoScalingClient(config);
- * const command = new RecordLifecycleActionHeartbeatCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RecordLifecycleActionHeartbeatCommandInput} for command's `input` shape.
- * @see {@link RecordLifecycleActionHeartbeatCommandOutput} for command's `response` shape.
- * @see {@link AutoScalingClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class RecordLifecycleActionHeartbeatCommand extends $Command<
-  RecordLifecycleActionHeartbeatCommandInput,
-  RecordLifecycleActionHeartbeatCommandOutput,
-  AutoScalingClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: RecordLifecycleActionHeartbeatCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: AutoScalingClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<RecordLifecycleActionHeartbeatCommandInput, RecordLifecycleActionHeartbeatCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "AutoScalingClient";
-    const commandName = "RecordLifecycleActionHeartbeatCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: RecordLifecycleActionHeartbeatType.filterSensitiveLog,
-      outputFilterSensitiveLog: RecordLifecycleActionHeartbeatAnswer.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: RecordLifecycleActionHeartbeatCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_queryRecordLifecycleActionHeartbeatCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<RecordLifecycleActionHeartbeatCommandOutput> {
-    return deserializeAws_queryRecordLifecycleActionHeartbeatCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/ResumeProcessesCommand.ts

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

package/commands/SetDesiredCapacityCommand.ts

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