@aws-sdk/client-application-auto-scaling 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,1689 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApplicationAutoScalingServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ApplicationAutoScalingClient"), exports);
-tslib_1.__exportStar(require("./ApplicationAutoScaling"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var ApplicationAutoScalingServiceException_1 = require("./models/ApplicationAutoScalingServiceException");
-Object.defineProperty(exports, "ApplicationAutoScalingServiceException", { enumerable: true, get: function () { return ApplicationAutoScalingServiceException_1.ApplicationAutoScalingServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AdjustmentType: () => AdjustmentType,
+  ApplicationAutoScaling: () => ApplicationAutoScaling,
+  ApplicationAutoScalingClient: () => ApplicationAutoScalingClient,
+  ApplicationAutoScalingServiceException: () => ApplicationAutoScalingServiceException,
+  ConcurrentUpdateException: () => ConcurrentUpdateException,
+  DeleteScalingPolicyCommand: () => DeleteScalingPolicyCommand,
+  DeleteScheduledActionCommand: () => DeleteScheduledActionCommand,
+  DeregisterScalableTargetCommand: () => DeregisterScalableTargetCommand,
+  DescribeScalableTargetsCommand: () => DescribeScalableTargetsCommand,
+  DescribeScalingActivitiesCommand: () => DescribeScalingActivitiesCommand,
+  DescribeScalingPoliciesCommand: () => DescribeScalingPoliciesCommand,
+  DescribeScheduledActionsCommand: () => DescribeScheduledActionsCommand,
+  FailedResourceAccessException: () => FailedResourceAccessException,
+  InternalServiceException: () => InternalServiceException,
+  InvalidNextTokenException: () => InvalidNextTokenException,
+  LimitExceededException: () => LimitExceededException,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  MetricAggregationType: () => MetricAggregationType,
+  MetricStatistic: () => MetricStatistic,
+  MetricType: () => MetricType,
+  ObjectNotFoundException: () => ObjectNotFoundException,
+  PolicyType: () => PolicyType,
+  PutScalingPolicyCommand: () => PutScalingPolicyCommand,
+  PutScheduledActionCommand: () => PutScheduledActionCommand,
+  RegisterScalableTargetCommand: () => RegisterScalableTargetCommand,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ScalableDimension: () => ScalableDimension,
+  ScalingActivityStatusCode: () => ScalingActivityStatusCode,
+  ServiceNamespace: () => ServiceNamespace,
+  TagResourceCommand: () => TagResourceCommand,
+  TooManyTagsException: () => TooManyTagsException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeScalableTargets: () => paginateDescribeScalableTargets,
+  paginateDescribeScalingActivities: () => paginateDescribeScalingActivities,
+  paginateDescribeScalingPolicies: () => paginateDescribeScalingPolicies,
+  paginateDescribeScheduledActions: () => paginateDescribeScheduledActions
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ApplicationAutoScalingClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "application-autoscaling"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ApplicationAutoScalingClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/ApplicationAutoScalingClient.ts
+var _ApplicationAutoScalingClient = class _ApplicationAutoScalingClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_ApplicationAutoScalingClient, "ApplicationAutoScalingClient");
+var ApplicationAutoScalingClient = _ApplicationAutoScalingClient;
+
+// src/ApplicationAutoScaling.ts
+
+
+// src/commands/DeleteScalingPolicyCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/ApplicationAutoScalingServiceException.ts
+
+var _ApplicationAutoScalingServiceException = class _ApplicationAutoScalingServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ApplicationAutoScalingServiceException.prototype);
+  }
+};
+__name(_ApplicationAutoScalingServiceException, "ApplicationAutoScalingServiceException");
+var ApplicationAutoScalingServiceException = _ApplicationAutoScalingServiceException;
+
+// src/models/models_0.ts
+var AdjustmentType = {
+  ChangeInCapacity: "ChangeInCapacity",
+  ExactCapacity: "ExactCapacity",
+  PercentChangeInCapacity: "PercentChangeInCapacity"
+};
+var _ConcurrentUpdateException = class _ConcurrentUpdateException extends ApplicationAutoScalingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConcurrentUpdateException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ConcurrentUpdateException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ConcurrentUpdateException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ConcurrentUpdateException, "ConcurrentUpdateException");
+var ConcurrentUpdateException = _ConcurrentUpdateException;
+var ScalableDimension = {
+  AppstreamFleetDesiredCapacity: "appstream:fleet:DesiredCapacity",
+  CassandraTableReadCapacityUnits: "cassandra:table:ReadCapacityUnits",
+  CassandraTableWriteCapacityUnits: "cassandra:table:WriteCapacityUnits",
+  ComprehendDocClassifierEndpointInferenceUnits: "comprehend:document-classifier-endpoint:DesiredInferenceUnits",
+  ComprehendEntityRecognizerEndpointInferenceUnits: "comprehend:entity-recognizer-endpoint:DesiredInferenceUnits",
+  CustomResourceScalableDimension: "custom-resource:ResourceType:Property",
+  DynamoDBIndexReadCapacityUnits: "dynamodb:index:ReadCapacityUnits",
+  DynamoDBIndexWriteCapacityUnits: "dynamodb:index:WriteCapacityUnits",
+  DynamoDBTableReadCapacityUnits: "dynamodb:table:ReadCapacityUnits",
+  DynamoDBTableWriteCapacityUnits: "dynamodb:table:WriteCapacityUnits",
+  EC2SpotFleetRequestTargetCapacity: "ec2:spot-fleet-request:TargetCapacity",
+  ECSServiceDesiredCount: "ecs:service:DesiredCount",
+  EMRInstanceGroupInstanceCount: "elasticmapreduce:instancegroup:InstanceCount",
+  ElastiCacheReplicationGroupNodeGroups: "elasticache:replication-group:NodeGroups",
+  ElastiCacheReplicationGroupReplicas: "elasticache:replication-group:Replicas",
+  KafkaBrokerStorageVolumeSize: "kafka:broker-storage:VolumeSize",
+  LambdaFunctionProvisionedConcurrency: "lambda:function:ProvisionedConcurrency",
+  NeptuneClusterReadReplicaCount: "neptune:cluster:ReadReplicaCount",
+  RDSClusterReadReplicaCount: "rds:cluster:ReadReplicaCount",
+  SageMakerInferenceComponentDesiredCopyCount: "sagemaker:inference-component:DesiredCopyCount",
+  SageMakerVariantDesiredInstanceCount: "sagemaker:variant:DesiredInstanceCount",
+  SageMakerVariantDesiredProvisionedConcurrency: "sagemaker:variant:DesiredProvisionedConcurrency"
+};
+var ServiceNamespace = {
+  APPSTREAM: "appstream",
+  CASSANDRA: "cassandra",
+  COMPREHEND: "comprehend",
+  CUSTOM_RESOURCE: "custom-resource",
+  DYNAMODB: "dynamodb",
+  EC2: "ec2",
+  ECS: "ecs",
+  ELASTICACHE: "elasticache",
+  EMR: "elasticmapreduce",
+  KAFKA: "kafka",
+  LAMBDA: "lambda",
+  NEPTUNE: "neptune",
+  RDS: "rds",
+  SAGEMAKER: "sagemaker"
+};
+var _InternalServiceException = class _InternalServiceException extends ApplicationAutoScalingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServiceException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServiceException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServiceException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalServiceException, "InternalServiceException");
+var InternalServiceException = _InternalServiceException;
+var _ObjectNotFoundException = class _ObjectNotFoundException extends ApplicationAutoScalingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ObjectNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ObjectNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ObjectNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ObjectNotFoundException, "ObjectNotFoundException");
+var ObjectNotFoundException = _ObjectNotFoundException;
+var _ValidationException = class _ValidationException extends ApplicationAutoScalingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _InvalidNextTokenException = class _InvalidNextTokenException extends ApplicationAutoScalingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidNextTokenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidNextTokenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidNextTokenException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidNextTokenException, "InvalidNextTokenException");
+var InvalidNextTokenException = _InvalidNextTokenException;
+var ScalingActivityStatusCode = {
+  Failed: "Failed",
+  InProgress: "InProgress",
+  Overridden: "Overridden",
+  Pending: "Pending",
+  Successful: "Successful",
+  Unfulfilled: "Unfulfilled"
+};
+var PolicyType = {
+  StepScaling: "StepScaling",
+  TargetTrackingScaling: "TargetTrackingScaling"
+};
+var MetricAggregationType = {
+  Average: "Average",
+  Maximum: "Maximum",
+  Minimum: "Minimum"
+};
+var MetricStatistic = {
+  Average: "Average",
+  Maximum: "Maximum",
+  Minimum: "Minimum",
+  SampleCount: "SampleCount",
+  Sum: "Sum"
+};
+var MetricType = {
+  ALBRequestCountPerTarget: "ALBRequestCountPerTarget",
+  AppStreamAverageCapacityUtilization: "AppStreamAverageCapacityUtilization",
+  CassandraReadCapacityUtilization: "CassandraReadCapacityUtilization",
+  CassandraWriteCapacityUtilization: "CassandraWriteCapacityUtilization",
+  ComprehendInferenceUtilization: "ComprehendInferenceUtilization",
+  DynamoDBReadCapacityUtilization: "DynamoDBReadCapacityUtilization",
+  DynamoDBWriteCapacityUtilization: "DynamoDBWriteCapacityUtilization",
+  EC2SpotFleetRequestAverageCPUUtilization: "EC2SpotFleetRequestAverageCPUUtilization",
+  EC2SpotFleetRequestAverageNetworkIn: "EC2SpotFleetRequestAverageNetworkIn",
+  EC2SpotFleetRequestAverageNetworkOut: "EC2SpotFleetRequestAverageNetworkOut",
+  ECSServiceAverageCPUUtilization: "ECSServiceAverageCPUUtilization",
+  ECSServiceAverageMemoryUtilization: "ECSServiceAverageMemoryUtilization",
+  ElastiCacheDatabaseCapacityUsageCountedForEvictPercentage: "ElastiCacheDatabaseCapacityUsageCountedForEvictPercentage",
+  ElastiCacheDatabaseMemoryUsageCountedForEvictPercentage: "ElastiCacheDatabaseMemoryUsageCountedForEvictPercentage",
+  ElastiCachePrimaryEngineCPUUtilization: "ElastiCachePrimaryEngineCPUUtilization",
+  ElastiCacheReplicaEngineCPUUtilization: "ElastiCacheReplicaEngineCPUUtilization",
+  KafkaBrokerStorageUtilization: "KafkaBrokerStorageUtilization",
+  LambdaProvisionedConcurrencyUtilization: "LambdaProvisionedConcurrencyUtilization",
+  NeptuneReaderAverageCPUUtilization: "NeptuneReaderAverageCPUUtilization",
+  RDSReaderAverageCPUUtilization: "RDSReaderAverageCPUUtilization",
+  RDSReaderAverageDatabaseConnections: "RDSReaderAverageDatabaseConnections",
+  SageMakerInferenceComponentInvocationsPerCopy: "SageMakerInferenceComponentInvocationsPerCopy",
+  SageMakerVariantInvocationsPerInstance: "SageMakerVariantInvocationsPerInstance",
+  SageMakerVariantProvisionedConcurrencyUtilization: "SageMakerVariantProvisionedConcurrencyUtilization"
+};
+var _FailedResourceAccessException = class _FailedResourceAccessException extends ApplicationAutoScalingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "FailedResourceAccessException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "FailedResourceAccessException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _FailedResourceAccessException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_FailedResourceAccessException, "FailedResourceAccessException");
+var FailedResourceAccessException = _FailedResourceAccessException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends ApplicationAutoScalingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+    this.ResourceName = opts.ResourceName;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _LimitExceededException = class _LimitExceededException extends ApplicationAutoScalingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _TooManyTagsException = class _TooManyTagsException extends ApplicationAutoScalingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+    this.Message = opts.Message;
+    this.ResourceName = opts.ResourceName;
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+
+// src/protocols/Aws_json1_1.ts
+var se_DeleteScalingPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteScalingPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteScalingPolicyCommand");
+var se_DeleteScheduledActionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteScheduledAction");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteScheduledActionCommand");
+var se_DeregisterScalableTargetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeregisterScalableTarget");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeregisterScalableTargetCommand");
+var se_DescribeScalableTargetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeScalableTargets");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeScalableTargetsCommand");
+var se_DescribeScalingActivitiesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeScalingActivities");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeScalingActivitiesCommand");
+var se_DescribeScalingPoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeScalingPolicies");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeScalingPoliciesCommand");
+var se_DescribeScheduledActionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeScheduledActions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeScheduledActionsCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTagsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsForResourceCommand");
+var se_PutScalingPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutScalingPolicy");
+  let body;
+  body = JSON.stringify(se_PutScalingPolicyRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutScalingPolicyCommand");
+var se_PutScheduledActionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutScheduledAction");
+  let body;
+  body = JSON.stringify(se_PutScheduledActionRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutScheduledActionCommand");
+var se_RegisterScalableTargetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RegisterScalableTarget");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RegisterScalableTargetCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var de_DeleteScalingPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteScalingPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteScalingPolicyCommand");
+var de_DeleteScalingPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "ObjectNotFoundException":
+    case "com.amazonaws.applicationautoscaling#ObjectNotFoundException":
+      throw await de_ObjectNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteScalingPolicyCommandError");
+var de_DeleteScheduledActionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteScheduledActionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteScheduledActionCommand");
+var de_DeleteScheduledActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "ObjectNotFoundException":
+    case "com.amazonaws.applicationautoscaling#ObjectNotFoundException":
+      throw await de_ObjectNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteScheduledActionCommandError");
+var de_DeregisterScalableTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeregisterScalableTargetCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeregisterScalableTargetCommand");
+var de_DeregisterScalableTargetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "ObjectNotFoundException":
+    case "com.amazonaws.applicationautoscaling#ObjectNotFoundException":
+      throw await de_ObjectNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeregisterScalableTargetCommandError");
+var de_DescribeScalableTargetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeScalableTargetsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeScalableTargetsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeScalableTargetsCommand");
+var de_DescribeScalableTargetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.applicationautoscaling#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeScalableTargetsCommandError");
+var de_DescribeScalingActivitiesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeScalingActivitiesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeScalingActivitiesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeScalingActivitiesCommand");
+var de_DescribeScalingActivitiesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.applicationautoscaling#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeScalingActivitiesCommandError");
+var de_DescribeScalingPoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeScalingPoliciesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeScalingPoliciesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeScalingPoliciesCommand");
+var de_DescribeScalingPoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "FailedResourceAccessException":
+    case "com.amazonaws.applicationautoscaling#FailedResourceAccessException":
+      throw await de_FailedResourceAccessExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.applicationautoscaling#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeScalingPoliciesCommandError");
+var de_DescribeScheduledActionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeScheduledActionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeScheduledActionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeScheduledActionsCommand");
+var de_DescribeScheduledActionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.applicationautoscaling#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeScheduledActionsCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.applicationautoscaling#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_PutScalingPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutScalingPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutScalingPolicyCommand");
+var de_PutScalingPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "FailedResourceAccessException":
+    case "com.amazonaws.applicationautoscaling#FailedResourceAccessException":
+      throw await de_FailedResourceAccessExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.applicationautoscaling#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ObjectNotFoundException":
+    case "com.amazonaws.applicationautoscaling#ObjectNotFoundException":
+      throw await de_ObjectNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutScalingPolicyCommandError");
+var de_PutScheduledActionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutScheduledActionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutScheduledActionCommand");
+var de_PutScheduledActionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.applicationautoscaling#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ObjectNotFoundException":
+    case "com.amazonaws.applicationautoscaling#ObjectNotFoundException":
+      throw await de_ObjectNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutScheduledActionCommandError");
+var de_RegisterScalableTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RegisterScalableTargetCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RegisterScalableTargetCommand");
+var de_RegisterScalableTargetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentUpdateException":
+    case "com.amazonaws.applicationautoscaling#ConcurrentUpdateException":
+      throw await de_ConcurrentUpdateExceptionRes(parsedOutput, context);
+    case "InternalServiceException":
+    case "com.amazonaws.applicationautoscaling#InternalServiceException":
+      throw await de_InternalServiceExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.applicationautoscaling#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RegisterScalableTargetCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.applicationautoscaling#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.applicationautoscaling#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ResourceNotFoundException":
+    case "com.amazonaws.applicationautoscaling#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.applicationautoscaling#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_ConcurrentUpdateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ConcurrentUpdateException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ConcurrentUpdateExceptionRes");
+var de_FailedResourceAccessExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new FailedResourceAccessException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_FailedResourceAccessExceptionRes");
+var de_InternalServiceExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalServiceException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalServiceExceptionRes");
+var de_InvalidNextTokenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidNextTokenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidNextTokenExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_ObjectNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ObjectNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ObjectNotFoundExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyTagsExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ValidationExceptionRes");
+var se_PutScalingPolicyRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    PolicyName: [],
+    PolicyType: [],
+    ResourceId: [],
+    ScalableDimension: [],
+    ServiceNamespace: [],
+    StepScalingPolicyConfiguration: (_) => se_StepScalingPolicyConfiguration(_, context),
+    TargetTrackingScalingPolicyConfiguration: (_) => se_TargetTrackingScalingPolicyConfiguration(_, context)
+  });
+}, "se_PutScalingPolicyRequest");
+var se_PutScheduledActionRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    EndTime: (_) => Math.round(_.getTime() / 1e3),
+    ResourceId: [],
+    ScalableDimension: [],
+    ScalableTargetAction: import_smithy_client._json,
+    Schedule: [],
+    ScheduledActionName: [],
+    ServiceNamespace: [],
+    StartTime: (_) => Math.round(_.getTime() / 1e3),
+    Timezone: []
+  });
+}, "se_PutScheduledActionRequest");
+var se_StepAdjustment = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    MetricIntervalLowerBound: import_smithy_client.serializeFloat,
+    MetricIntervalUpperBound: import_smithy_client.serializeFloat,
+    ScalingAdjustment: []
+  });
+}, "se_StepAdjustment");
+var se_StepAdjustments = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_StepAdjustment(entry, context);
+  });
+}, "se_StepAdjustments");
+var se_StepScalingPolicyConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AdjustmentType: [],
+    Cooldown: [],
+    MetricAggregationType: [],
+    MinAdjustmentMagnitude: [],
+    StepAdjustments: (_) => se_StepAdjustments(_, context)
+  });
+}, "se_StepScalingPolicyConfiguration");
+var se_TargetTrackingScalingPolicyConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    CustomizedMetricSpecification: import_smithy_client._json,
+    DisableScaleIn: [],
+    PredefinedMetricSpecification: import_smithy_client._json,
+    ScaleInCooldown: [],
+    ScaleOutCooldown: [],
+    TargetValue: import_smithy_client.serializeFloat
+  });
+}, "se_TargetTrackingScalingPolicyConfiguration");
+var de_DescribeScalableTargetsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    ScalableTargets: (_) => de_ScalableTargets(_, context)
+  });
+}, "de_DescribeScalableTargetsResponse");
+var de_DescribeScalingActivitiesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    ScalingActivities: (_) => de_ScalingActivities(_, context)
+  });
+}, "de_DescribeScalingActivitiesResponse");
+var de_DescribeScalingPoliciesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    ScalingPolicies: (_) => de_ScalingPolicies(_, context)
+  });
+}, "de_DescribeScalingPoliciesResponse");
+var de_DescribeScheduledActionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    ScheduledActions: (_) => de_ScheduledActions(_, context)
+  });
+}, "de_DescribeScheduledActionsResponse");
+var de_ScalableTarget = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    MaxCapacity: import_smithy_client.expectInt32,
+    MinCapacity: import_smithy_client.expectInt32,
+    ResourceId: import_smithy_client.expectString,
+    RoleARN: import_smithy_client.expectString,
+    ScalableDimension: import_smithy_client.expectString,
+    ScalableTargetARN: import_smithy_client.expectString,
+    ServiceNamespace: import_smithy_client.expectString,
+    SuspendedState: import_smithy_client._json
+  });
+}, "de_ScalableTarget");
+var de_ScalableTargets = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ScalableTarget(entry, context);
+  });
+  return retVal;
+}, "de_ScalableTargets");
+var de_ScalingActivities = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ScalingActivity(entry, context);
+  });
+  return retVal;
+}, "de_ScalingActivities");
+var de_ScalingActivity = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ActivityId: import_smithy_client.expectString,
+    Cause: import_smithy_client.expectString,
+    Description: import_smithy_client.expectString,
+    Details: import_smithy_client.expectString,
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NotScaledReasons: import_smithy_client._json,
+    ResourceId: import_smithy_client.expectString,
+    ScalableDimension: import_smithy_client.expectString,
+    ServiceNamespace: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    StatusCode: import_smithy_client.expectString,
+    StatusMessage: import_smithy_client.expectString
+  });
+}, "de_ScalingActivity");
+var de_ScalingPolicies = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ScalingPolicy(entry, context);
+  });
+  return retVal;
+}, "de_ScalingPolicies");
+var de_ScalingPolicy = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Alarms: import_smithy_client._json,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    PolicyARN: import_smithy_client.expectString,
+    PolicyName: import_smithy_client.expectString,
+    PolicyType: import_smithy_client.expectString,
+    ResourceId: import_smithy_client.expectString,
+    ScalableDimension: import_smithy_client.expectString,
+    ServiceNamespace: import_smithy_client.expectString,
+    StepScalingPolicyConfiguration: (_) => de_StepScalingPolicyConfiguration(_, context),
+    TargetTrackingScalingPolicyConfiguration: (_) => de_TargetTrackingScalingPolicyConfiguration(_, context)
+  });
+}, "de_ScalingPolicy");
+var de_ScheduledAction = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ResourceId: import_smithy_client.expectString,
+    ScalableDimension: import_smithy_client.expectString,
+    ScalableTargetAction: import_smithy_client._json,
+    Schedule: import_smithy_client.expectString,
+    ScheduledActionARN: import_smithy_client.expectString,
+    ScheduledActionName: import_smithy_client.expectString,
+    ServiceNamespace: import_smithy_client.expectString,
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Timezone: import_smithy_client.expectString
+  });
+}, "de_ScheduledAction");
+var de_ScheduledActions = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ScheduledAction(entry, context);
+  });
+  return retVal;
+}, "de_ScheduledActions");
+var de_StepAdjustment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MetricIntervalLowerBound: import_smithy_client.limitedParseDouble,
+    MetricIntervalUpperBound: import_smithy_client.limitedParseDouble,
+    ScalingAdjustment: import_smithy_client.expectInt32
+  });
+}, "de_StepAdjustment");
+var de_StepAdjustments = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_StepAdjustment(entry, context);
+  });
+  return retVal;
+}, "de_StepAdjustments");
+var de_StepScalingPolicyConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AdjustmentType: import_smithy_client.expectString,
+    Cooldown: import_smithy_client.expectInt32,
+    MetricAggregationType: import_smithy_client.expectString,
+    MinAdjustmentMagnitude: import_smithy_client.expectInt32,
+    StepAdjustments: (_) => de_StepAdjustments(_, context)
+  });
+}, "de_StepScalingPolicyConfiguration");
+var de_TargetTrackingScalingPolicyConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CustomizedMetricSpecification: import_smithy_client._json,
+    DisableScaleIn: import_smithy_client.expectBoolean,
+    PredefinedMetricSpecification: import_smithy_client._json,
+    ScaleInCooldown: import_smithy_client.expectInt32,
+    ScaleOutCooldown: import_smithy_client.expectInt32,
+    TargetValue: import_smithy_client.limitedParseDouble
+  });
+}, "de_TargetTrackingScalingPolicyConfiguration");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(ApplicationAutoScalingServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `AnyScaleFrontendService.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/DeleteScalingPolicyCommand.ts
+var _DeleteScalingPolicyCommand = class _DeleteScalingPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "DeleteScalingPolicy", {}).n("ApplicationAutoScalingClient", "DeleteScalingPolicyCommand").f(void 0, void 0).ser(se_DeleteScalingPolicyCommand).de(de_DeleteScalingPolicyCommand).build() {
+};
+__name(_DeleteScalingPolicyCommand, "DeleteScalingPolicyCommand");
+var DeleteScalingPolicyCommand = _DeleteScalingPolicyCommand;
+
+// src/commands/DeleteScheduledActionCommand.ts
+
+
+
+
+var _DeleteScheduledActionCommand = class _DeleteScheduledActionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "DeleteScheduledAction", {}).n("ApplicationAutoScalingClient", "DeleteScheduledActionCommand").f(void 0, void 0).ser(se_DeleteScheduledActionCommand).de(de_DeleteScheduledActionCommand).build() {
+};
+__name(_DeleteScheduledActionCommand, "DeleteScheduledActionCommand");
+var DeleteScheduledActionCommand = _DeleteScheduledActionCommand;
+
+// src/commands/DeregisterScalableTargetCommand.ts
+
+
+
+
+var _DeregisterScalableTargetCommand = class _DeregisterScalableTargetCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "DeregisterScalableTarget", {}).n("ApplicationAutoScalingClient", "DeregisterScalableTargetCommand").f(void 0, void 0).ser(se_DeregisterScalableTargetCommand).de(de_DeregisterScalableTargetCommand).build() {
+};
+__name(_DeregisterScalableTargetCommand, "DeregisterScalableTargetCommand");
+var DeregisterScalableTargetCommand = _DeregisterScalableTargetCommand;
+
+// src/commands/DescribeScalableTargetsCommand.ts
+
+
+
+
+var _DescribeScalableTargetsCommand = class _DescribeScalableTargetsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "DescribeScalableTargets", {}).n("ApplicationAutoScalingClient", "DescribeScalableTargetsCommand").f(void 0, void 0).ser(se_DescribeScalableTargetsCommand).de(de_DescribeScalableTargetsCommand).build() {
+};
+__name(_DescribeScalableTargetsCommand, "DescribeScalableTargetsCommand");
+var DescribeScalableTargetsCommand = _DescribeScalableTargetsCommand;
+
+// src/commands/DescribeScalingActivitiesCommand.ts
+
+
+
+
+var _DescribeScalingActivitiesCommand = class _DescribeScalingActivitiesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "DescribeScalingActivities", {}).n("ApplicationAutoScalingClient", "DescribeScalingActivitiesCommand").f(void 0, void 0).ser(se_DescribeScalingActivitiesCommand).de(de_DescribeScalingActivitiesCommand).build() {
+};
+__name(_DescribeScalingActivitiesCommand, "DescribeScalingActivitiesCommand");
+var DescribeScalingActivitiesCommand = _DescribeScalingActivitiesCommand;
+
+// src/commands/DescribeScalingPoliciesCommand.ts
+
+
+
+
+var _DescribeScalingPoliciesCommand = class _DescribeScalingPoliciesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "DescribeScalingPolicies", {}).n("ApplicationAutoScalingClient", "DescribeScalingPoliciesCommand").f(void 0, void 0).ser(se_DescribeScalingPoliciesCommand).de(de_DescribeScalingPoliciesCommand).build() {
+};
+__name(_DescribeScalingPoliciesCommand, "DescribeScalingPoliciesCommand");
+var DescribeScalingPoliciesCommand = _DescribeScalingPoliciesCommand;
+
+// src/commands/DescribeScheduledActionsCommand.ts
+
+
+
+
+var _DescribeScheduledActionsCommand = class _DescribeScheduledActionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "DescribeScheduledActions", {}).n("ApplicationAutoScalingClient", "DescribeScheduledActionsCommand").f(void 0, void 0).ser(se_DescribeScheduledActionsCommand).de(de_DescribeScheduledActionsCommand).build() {
+};
+__name(_DescribeScheduledActionsCommand, "DescribeScheduledActionsCommand");
+var DescribeScheduledActionsCommand = _DescribeScheduledActionsCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "ListTagsForResource", {}).n("ApplicationAutoScalingClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/PutScalingPolicyCommand.ts
+
+
+
+
+var _PutScalingPolicyCommand = class _PutScalingPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "PutScalingPolicy", {}).n("ApplicationAutoScalingClient", "PutScalingPolicyCommand").f(void 0, void 0).ser(se_PutScalingPolicyCommand).de(de_PutScalingPolicyCommand).build() {
+};
+__name(_PutScalingPolicyCommand, "PutScalingPolicyCommand");
+var PutScalingPolicyCommand = _PutScalingPolicyCommand;
+
+// src/commands/PutScheduledActionCommand.ts
+
+
+
+
+var _PutScheduledActionCommand = class _PutScheduledActionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "PutScheduledAction", {}).n("ApplicationAutoScalingClient", "PutScheduledActionCommand").f(void 0, void 0).ser(se_PutScheduledActionCommand).de(de_PutScheduledActionCommand).build() {
+};
+__name(_PutScheduledActionCommand, "PutScheduledActionCommand");
+var PutScheduledActionCommand = _PutScheduledActionCommand;
+
+// src/commands/RegisterScalableTargetCommand.ts
+
+
+
+
+var _RegisterScalableTargetCommand = class _RegisterScalableTargetCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "RegisterScalableTarget", {}).n("ApplicationAutoScalingClient", "RegisterScalableTargetCommand").f(void 0, void 0).ser(se_RegisterScalableTargetCommand).de(de_RegisterScalableTargetCommand).build() {
+};
+__name(_RegisterScalableTargetCommand, "RegisterScalableTargetCommand");
+var RegisterScalableTargetCommand = _RegisterScalableTargetCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "TagResource", {}).n("ApplicationAutoScalingClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AnyScaleFrontendService", "UntagResource", {}).n("ApplicationAutoScalingClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/ApplicationAutoScaling.ts
+var commands = {
+  DeleteScalingPolicyCommand,
+  DeleteScheduledActionCommand,
+  DeregisterScalableTargetCommand,
+  DescribeScalableTargetsCommand,
+  DescribeScalingActivitiesCommand,
+  DescribeScalingPoliciesCommand,
+  DescribeScheduledActionsCommand,
+  ListTagsForResourceCommand,
+  PutScalingPolicyCommand,
+  PutScheduledActionCommand,
+  RegisterScalableTargetCommand,
+  TagResourceCommand,
+  UntagResourceCommand
+};
+var _ApplicationAutoScaling = class _ApplicationAutoScaling extends ApplicationAutoScalingClient {
+};
+__name(_ApplicationAutoScaling, "ApplicationAutoScaling");
+var ApplicationAutoScaling = _ApplicationAutoScaling;
+(0, import_smithy_client.createAggregatedClient)(commands, ApplicationAutoScaling);
+
+// src/pagination/DescribeScalableTargetsPaginator.ts
+var import_core = require("@smithy/core");
+var paginateDescribeScalableTargets = (0, import_core.createPaginator)(ApplicationAutoScalingClient, DescribeScalableTargetsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/DescribeScalingActivitiesPaginator.ts
+
+var paginateDescribeScalingActivities = (0, import_core.createPaginator)(ApplicationAutoScalingClient, DescribeScalingActivitiesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/DescribeScalingPoliciesPaginator.ts
+
+var paginateDescribeScalingPolicies = (0, import_core.createPaginator)(ApplicationAutoScalingClient, DescribeScalingPoliciesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/DescribeScheduledActionsPaginator.ts
+
+var paginateDescribeScheduledActions = (0, import_core.createPaginator)(ApplicationAutoScalingClient, DescribeScheduledActionsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdjustmentType,
+  ApplicationAutoScaling,
+  ApplicationAutoScalingClient,
+  ApplicationAutoScalingServiceException,
+  ConcurrentUpdateException,
+  DeleteScalingPolicyCommand,
+  DeleteScheduledActionCommand,
+  DeregisterScalableTargetCommand,
+  DescribeScalableTargetsCommand,
+  DescribeScalingActivitiesCommand,
+  DescribeScalingPoliciesCommand,
+  DescribeScheduledActionsCommand,
+  FailedResourceAccessException,
+  InternalServiceException,
+  InvalidNextTokenException,
+  LimitExceededException,
+  ListTagsForResourceCommand,
+  MetricAggregationType,
+  MetricStatistic,
+  MetricType,
+  ObjectNotFoundException,
+  PolicyType,
+  PutScalingPolicyCommand,
+  PutScheduledActionCommand,
+  RegisterScalableTargetCommand,
+  ResourceNotFoundException,
+  ScalableDimension,
+  ScalingActivityStatusCode,
+  ServiceNamespace,
+  TagResourceCommand,
+  TooManyTagsException,
+  UntagResourceCommand,
+  ValidationException,
+  __Client,
+  paginateDescribeScalableTargets,
+  paginateDescribeScalingActivities,
+  paginateDescribeScalingPolicies,
+  paginateDescribeScheduledActions
+});