@aws-sdk/client-auto-scaling-plans 3.927.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class AutoScalingPlansClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,14 +110,14 @@ class AutoScalingPlansClient extends smithyClient.Client {
     }
 }
 
-class AutoScalingPlansServiceException extends smithyClient.ServiceException {
+let AutoScalingPlansServiceException$1 = class AutoScalingPlansServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, AutoScalingPlansServiceException.prototype);
     }
-}
+};
 
-class ConcurrentUpdateException extends AutoScalingPlansServiceException {
+let ConcurrentUpdateException$1 = class ConcurrentUpdateException extends AutoScalingPlansServiceException$1 {
     name = "ConcurrentUpdateException";
     $fault = "server";
     Message;
@@ -130,7 +130,7 @@ class ConcurrentUpdateException extends AutoScalingPlansServiceException {
         Object.setPrototypeOf(this, ConcurrentUpdateException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const MetricStatistic = {
     Average: "Average",
     Maximum: "Maximum",
@@ -189,7 +189,7 @@ const ScalingMetricType = {
     RDSReaderAverageCPUUtilization: "RDSReaderAverageCPUUtilization",
     RDSReaderAverageDatabaseConnections: "RDSReaderAverageDatabaseConnections",
 };
-class InternalServiceException extends AutoScalingPlansServiceException {
+let InternalServiceException$1 = class InternalServiceException extends AutoScalingPlansServiceException$1 {
     name = "InternalServiceException";
     $fault = "server";
     Message;
@@ -202,8 +202,8 @@ class InternalServiceException extends AutoScalingPlansServiceException {
         Object.setPrototypeOf(this, InternalServiceException.prototype);
         this.Message = opts.Message;
     }
-}
-class LimitExceededException extends AutoScalingPlansServiceException {
+};
+let LimitExceededException$1 = class LimitExceededException extends AutoScalingPlansServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     Message;
@@ -216,8 +216,8 @@ class LimitExceededException extends AutoScalingPlansServiceException {
         Object.setPrototypeOf(this, LimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class ValidationException extends AutoScalingPlansServiceException {
+};
+let ValidationException$1 = class ValidationException extends AutoScalingPlansServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -230,8 +230,8 @@ class ValidationException extends AutoScalingPlansServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.Message = opts.Message;
     }
-}
-class ObjectNotFoundException extends AutoScalingPlansServiceException {
+};
+let ObjectNotFoundException$1 = class ObjectNotFoundException extends AutoScalingPlansServiceException$1 {
     name = "ObjectNotFoundException";
     $fault = "client";
     Message;
@@ -244,7 +244,7 @@ class ObjectNotFoundException extends AutoScalingPlansServiceException {
         Object.setPrototypeOf(this, ObjectNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const PolicyType = {
     TargetTrackingScaling: "TargetTrackingScaling",
 };
@@ -253,7 +253,7 @@ const ScalingStatusCode = {
     Inactive: "Inactive",
     PartiallyActive: "PartiallyActive",
 };
-class InvalidNextTokenException extends AutoScalingPlansServiceException {
+let InvalidNextTokenException$1 = class InvalidNextTokenException extends AutoScalingPlansServiceException$1 {
     name = "InvalidNextTokenException";
     $fault = "client";
     Message;
@@ -266,7 +266,7 @@ class InvalidNextTokenException extends AutoScalingPlansServiceException {
         Object.setPrototypeOf(this, InvalidNextTokenException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const ScalingPlanStatusCode = {
     Active: "Active",
     ActiveWithProblems: "ActiveWithProblems",
@@ -284,452 +284,405 @@ const ForecastDataType = {
     ScheduledActionMinCapacity: "ScheduledActionMinCapacity",
 };
 
-const se_CreateScalingPlanCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateScalingPlan");
-    let body;
-    body = JSON.stringify(se_CreateScalingPlanRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteScalingPlanCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteScalingPlan");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeScalingPlanResourcesCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeScalingPlanResources");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeScalingPlansCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeScalingPlans");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetScalingPlanResourceForecastDataCommand = async (input, context) => {
-    const headers = sharedHeaders("GetScalingPlanResourceForecastData");
-    let body;
-    body = JSON.stringify(se_GetScalingPlanResourceForecastDataRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateScalingPlanCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateScalingPlan");
-    let body;
-    body = JSON.stringify(se_UpdateScalingPlanRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_CreateScalingPlanCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteScalingPlanCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeScalingPlanResourcesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeScalingPlanResourcesResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeScalingPlansCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeScalingPlansResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetScalingPlanResourceForecastDataCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetScalingPlanResourceForecastDataResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateScalingPlanCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ConcurrentUpdateException":
-        case "com.amazonaws.autoscalingplans#ConcurrentUpdateException":
-            throw await de_ConcurrentUpdateExceptionRes(parsedOutput);
-        case "InternalServiceException":
-        case "com.amazonaws.autoscalingplans#InternalServiceException":
-            throw await de_InternalServiceExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.autoscalingplans#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.autoscalingplans#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ObjectNotFoundException":
-        case "com.amazonaws.autoscalingplans#ObjectNotFoundException":
-            throw await de_ObjectNotFoundExceptionRes(parsedOutput);
-        case "InvalidNextTokenException":
-        case "com.amazonaws.autoscalingplans#InvalidNextTokenException":
-            throw await de_InvalidNextTokenExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_ConcurrentUpdateExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ConcurrentUpdateException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InternalServiceExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InternalServiceException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidNextTokenExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidNextTokenException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ObjectNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ObjectNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_CreateScalingPlanRequest = (input, context) => {
-    return smithyClient.take(input, {
-        ApplicationSource: smithyClient._json,
-        ScalingInstructions: (_) => se_ScalingInstructions(_),
-        ScalingPlanName: [],
-    });
-};
-const se_GetScalingPlanResourceForecastDataRequest = (input, context) => {
-    return smithyClient.take(input, {
-        EndTime: (_) => _.getTime() / 1_000,
-        ForecastDataType: [],
-        ResourceId: [],
-        ScalableDimension: [],
-        ScalingPlanName: [],
-        ScalingPlanVersion: [],
-        ServiceNamespace: [],
-        StartTime: (_) => _.getTime() / 1_000,
-    });
-};
-const se_ScalingInstruction = (input, context) => {
-    return smithyClient.take(input, {
-        CustomizedLoadMetricSpecification: smithyClient._json,
-        DisableDynamicScaling: [],
-        MaxCapacity: [],
-        MinCapacity: [],
-        PredefinedLoadMetricSpecification: smithyClient._json,
-        PredictiveScalingMaxCapacityBehavior: [],
-        PredictiveScalingMaxCapacityBuffer: [],
-        PredictiveScalingMode: [],
-        ResourceId: [],
-        ScalableDimension: [],
-        ScalingPolicyUpdateBehavior: [],
-        ScheduledActionBufferTime: [],
-        ServiceNamespace: [],
-        TargetTrackingConfigurations: (_) => se_TargetTrackingConfigurations(_),
-    });
-};
-const se_ScalingInstructions = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_ScalingInstruction(entry);
-    });
-};
-const se_TargetTrackingConfiguration = (input, context) => {
-    return smithyClient.take(input, {
-        CustomizedScalingMetricSpecification: smithyClient._json,
-        DisableScaleIn: [],
-        EstimatedInstanceWarmup: [],
-        PredefinedScalingMetricSpecification: smithyClient._json,
-        ScaleInCooldown: [],
-        ScaleOutCooldown: [],
-        TargetValue: smithyClient.serializeFloat,
-    });
-};
-const se_TargetTrackingConfigurations = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_TargetTrackingConfiguration(entry);
-    });
-};
-const se_UpdateScalingPlanRequest = (input, context) => {
-    return smithyClient.take(input, {
-        ApplicationSource: smithyClient._json,
-        ScalingInstructions: (_) => se_ScalingInstructions(_),
-        ScalingPlanName: [],
-        ScalingPlanVersion: [],
-    });
-};
-const de_Datapoint = (output, context) => {
-    return smithyClient.take(output, {
-        Timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Value: smithyClient.limitedParseDouble,
-    });
-};
-const de_Datapoints = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Datapoint(entry);
-    });
-    return retVal;
-};
-const de_DescribeScalingPlanResourcesResponse = (output, context) => {
-    return smithyClient.take(output, {
-        NextToken: smithyClient.expectString,
-        ScalingPlanResources: (_) => de_ScalingPlanResources(_),
-    });
-};
-const de_DescribeScalingPlansResponse = (output, context) => {
-    return smithyClient.take(output, {
-        NextToken: smithyClient.expectString,
-        ScalingPlans: (_) => de_ScalingPlans(_),
-    });
-};
-const de_GetScalingPlanResourceForecastDataResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Datapoints: (_) => de_Datapoints(_),
-    });
-};
-const de_ScalingInstruction = (output, context) => {
-    return smithyClient.take(output, {
-        CustomizedLoadMetricSpecification: smithyClient._json,
-        DisableDynamicScaling: smithyClient.expectBoolean,
-        MaxCapacity: smithyClient.expectInt32,
-        MinCapacity: smithyClient.expectInt32,
-        PredefinedLoadMetricSpecification: smithyClient._json,
-        PredictiveScalingMaxCapacityBehavior: smithyClient.expectString,
-        PredictiveScalingMaxCapacityBuffer: smithyClient.expectInt32,
-        PredictiveScalingMode: smithyClient.expectString,
-        ResourceId: smithyClient.expectString,
-        ScalableDimension: smithyClient.expectString,
-        ScalingPolicyUpdateBehavior: smithyClient.expectString,
-        ScheduledActionBufferTime: smithyClient.expectInt32,
-        ServiceNamespace: smithyClient.expectString,
-        TargetTrackingConfigurations: (_) => de_TargetTrackingConfigurations(_),
-    });
-};
-const de_ScalingInstructions = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ScalingInstruction(entry);
-    });
-    return retVal;
-};
-const de_ScalingPlan = (output, context) => {
-    return smithyClient.take(output, {
-        ApplicationSource: smithyClient._json,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ScalingInstructions: (_) => de_ScalingInstructions(_),
-        ScalingPlanName: smithyClient.expectString,
-        ScalingPlanVersion: smithyClient.expectLong,
-        StatusCode: smithyClient.expectString,
-        StatusMessage: smithyClient.expectString,
-        StatusStartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_ScalingPlanResource = (output, context) => {
-    return smithyClient.take(output, {
-        ResourceId: smithyClient.expectString,
-        ScalableDimension: smithyClient.expectString,
-        ScalingPlanName: smithyClient.expectString,
-        ScalingPlanVersion: smithyClient.expectLong,
-        ScalingPolicies: (_) => de_ScalingPolicies(_),
-        ScalingStatusCode: smithyClient.expectString,
-        ScalingStatusMessage: smithyClient.expectString,
-        ServiceNamespace: smithyClient.expectString,
-    });
-};
-const de_ScalingPlanResources = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ScalingPlanResource(entry);
-    });
-    return retVal;
-};
-const de_ScalingPlans = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ScalingPlan(entry);
-    });
-    return retVal;
-};
-const de_ScalingPolicies = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ScalingPolicy(entry);
-    });
-    return retVal;
-};
-const de_ScalingPolicy = (output, context) => {
-    return smithyClient.take(output, {
-        PolicyName: smithyClient.expectString,
-        PolicyType: smithyClient.expectString,
-        TargetTrackingConfiguration: (_) => de_TargetTrackingConfiguration(_),
-    });
-};
-const de_TargetTrackingConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        CustomizedScalingMetricSpecification: smithyClient._json,
-        DisableScaleIn: smithyClient.expectBoolean,
-        EstimatedInstanceWarmup: smithyClient.expectInt32,
-        PredefinedScalingMetricSpecification: smithyClient._json,
-        ScaleInCooldown: smithyClient.expectInt32,
-        ScaleOutCooldown: smithyClient.expectInt32,
-        TargetValue: smithyClient.limitedParseDouble,
-    });
-};
-const de_TargetTrackingConfigurations = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_TargetTrackingConfiguration(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (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"],
-});
-const throwDefaultError = smithyClient.withBaseException(AutoScalingPlansServiceException);
-const buildHttpRpcRequest = 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 (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": `AnyScaleScalingPlannerFrontendService.${operation}`,
-    };
-}
+const _AS = "ApplicationSource";
+const _ASp = "ApplicationSources";
+const _CFSARN = "CloudFormationStackARN";
+const _CLMS = "CustomizedLoadMetricSpecification";
+const _CSMS = "CustomizedScalingMetricSpecification";
+const _CSP = "CreateScalingPlan";
+const _CSPR = "CreateScalingPlanRequest";
+const _CSPRr = "CreateScalingPlanResponse";
+const _CT = "CreationTime";
+const _CUE = "ConcurrentUpdateException";
+const _D = "Dimensions";
+const _DDS = "DisableDynamicScaling";
+const _DSI = "DisableScaleIn";
+const _DSP = "DeleteScalingPlan";
+const _DSPR = "DeleteScalingPlanRequest";
+const _DSPRR = "DescribeScalingPlanResourcesRequest";
+const _DSPRRe = "DescribeScalingPlanResourcesResponse";
+const _DSPRe = "DeleteScalingPlanResponse";
+const _DSPRes = "DescribeScalingPlansRequest";
+const _DSPResc = "DescribeScalingPlansResponse";
+const _DSPRescr = "DescribeScalingPlanResources";
+const _DSPe = "DescribeScalingPlans";
+const _Da = "Datapoint";
+const _Dat = "Datapoints";
+const _EIW = "EstimatedInstanceWarmup";
+const _ET = "EndTime";
+const _FDT = "ForecastDataType";
+const _GSPRFD = "GetScalingPlanResourceForecastData";
+const _GSPRFDR = "GetScalingPlanResourceForecastDataRequest";
+const _GSPRFDRe = "GetScalingPlanResourceForecastDataResponse";
+const _INTE = "InvalidNextTokenException";
+const _ISE = "InternalServiceException";
+const _K = "Key";
+const _LEE = "LimitExceededException";
+const _M = "Message";
+const _MC = "MinCapacity";
+const _MCa = "MaxCapacity";
+const _MD = "MetricDimension";
+const _MDe = "MetricDimensions";
+const _MN = "MetricName";
+const _MR = "MaxResults";
+const _N = "Namespace";
+const _NT = "NextToken";
+const _Na = "Name";
+const _ONFE = "ObjectNotFoundException";
+const _PLMS = "PredefinedLoadMetricSpecification";
+const _PLMT = "PredefinedLoadMetricType";
+const _PN = "PolicyName";
+const _PSM = "PredictiveScalingMode";
+const _PSMCB = "PredictiveScalingMaxCapacityBehavior";
+const _PSMCBr = "PredictiveScalingMaxCapacityBuffer";
+const _PSMS = "PredefinedScalingMetricSpecification";
+const _PSMT = "PredefinedScalingMetricType";
+const _PT = "PolicyType";
+const _RI = "ResourceId";
+const _RL = "ResourceLabel";
+const _S = "Statistic";
+const _SABT = "ScheduledActionBufferTime";
+const _SC = "StatusCode";
+const _SD = "ScalableDimension";
+const _SI = "ScalingInstructions";
+const _SIC = "ScaleInCooldown";
+const _SIc = "ScalingInstruction";
+const _SM = "StatusMessage";
+const _SN = "ServiceNamespace";
+const _SOC = "ScaleOutCooldown";
+const _SP = "ScalingPlans";
+const _SPN = "ScalingPlanName";
+const _SPNc = "ScalingPlanNames";
+const _SPR = "ScalingPlanResources";
+const _SPRc = "ScalingPlanResource";
+const _SPUB = "ScalingPolicyUpdateBehavior";
+const _SPV = "ScalingPlanVersion";
+const _SPc = "ScalingPlan";
+const _SPca = "ScalingPolicies";
+const _SPcal = "ScalingPolicy";
+const _SSC = "ScalingStatusCode";
+const _SSM = "ScalingStatusMessage";
+const _SST = "StatusStartTime";
+const _ST = "StartTime";
+const _T = "Timestamp";
+const _TF = "TagFilters";
+const _TFa = "TagFilter";
+const _TTC = "TargetTrackingConfigurations";
+const _TTCa = "TargetTrackingConfiguration";
+const _TV = "TargetValue";
+const _U = "Unit";
+const _USP = "UpdateScalingPlan";
+const _USPR = "UpdateScalingPlanRequest";
+const _USPRp = "UpdateScalingPlanResponse";
+const _V = "Value";
+const _VE = "ValidationException";
+const _Va = "Values";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _hE = "httpError";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.autoscalingplans";
+const n0 = "com.amazonaws.autoscalingplans";
+var ApplicationSource = [3, n0, _AS, 0, [_CFSARN, _TF], [0, () => TagFilters]];
+var ConcurrentUpdateException = [
+    -3,
+    n0,
+    _CUE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+        [_aQE]: [`ConcurrentUpdateException`, 500],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConcurrentUpdateException, ConcurrentUpdateException$1);
+var CreateScalingPlanRequest = [
+    3,
+    n0,
+    _CSPR,
+    0,
+    [_SPN, _AS, _SI],
+    [0, () => ApplicationSource, () => ScalingInstructions],
+];
+var CreateScalingPlanResponse = [3, n0, _CSPRr, 0, [_SPV], [1]];
+var CustomizedLoadMetricSpecification = [
+    3,
+    n0,
+    _CLMS,
+    0,
+    [_MN, _N, _D, _S, _U],
+    [0, 0, () => MetricDimensions, 0, 0],
+];
+var CustomizedScalingMetricSpecification = [
+    3,
+    n0,
+    _CSMS,
+    0,
+    [_MN, _N, _D, _S, _U],
+    [0, 0, () => MetricDimensions, 0, 0],
+];
+var Datapoint = [3, n0, _Da, 0, [_T, _V], [4, 1]];
+var DeleteScalingPlanRequest = [3, n0, _DSPR, 0, [_SPN, _SPV], [0, 1]];
+var DeleteScalingPlanResponse = [3, n0, _DSPRe, 0, [], []];
+var DescribeScalingPlanResourcesRequest = [
+    3,
+    n0,
+    _DSPRR,
+    0,
+    [_SPN, _SPV, _MR, _NT],
+    [0, 1, 1, 0],
+];
+var DescribeScalingPlanResourcesResponse = [
+    3,
+    n0,
+    _DSPRRe,
+    0,
+    [_SPR, _NT],
+    [() => ScalingPlanResources, 0],
+];
+var DescribeScalingPlansRequest = [
+    3,
+    n0,
+    _DSPRes,
+    0,
+    [_SPNc, _SPV, _ASp, _MR, _NT],
+    [64 | 0, 1, () => ApplicationSources, 1, 0],
+];
+var DescribeScalingPlansResponse = [
+    3,
+    n0,
+    _DSPResc,
+    0,
+    [_SP, _NT],
+    [() => ScalingPlans, 0],
+];
+var GetScalingPlanResourceForecastDataRequest = [
+    3,
+    n0,
+    _GSPRFDR,
+    0,
+    [_SPN, _SPV, _SN, _RI, _SD, _FDT, _ST, _ET],
+    [0, 1, 0, 0, 0, 0, 4, 4],
+];
+var GetScalingPlanResourceForecastDataResponse = [
+    3,
+    n0,
+    _GSPRFDRe,
+    0,
+    [_Dat],
+    [() => Datapoints],
+];
+var InternalServiceException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+        [_aQE]: [`InternalServiceException`, 500],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServiceException, InternalServiceException$1);
+var InvalidNextTokenException = [
+    -3,
+    n0,
+    _INTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`InvalidNextTokenException`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidNextTokenException, InvalidNextTokenException$1);
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`LimitExceededException`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var MetricDimension = [3, n0, _MD, 0, [_Na, _V], [0, 0]];
+var ObjectNotFoundException = [
+    -3,
+    n0,
+    _ONFE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`ObjectNotFoundException`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ObjectNotFoundException, ObjectNotFoundException$1);
+var PredefinedLoadMetricSpecification = [3, n0, _PLMS, 0, [_PLMT, _RL], [0, 0]];
+var PredefinedScalingMetricSpecification = [3, n0, _PSMS, 0, [_PSMT, _RL], [0, 0]];
+var ScalingInstruction = [
+    3,
+    n0,
+    _SIc,
+    0,
+    [_SN, _RI, _SD, _MC, _MCa, _TTC, _PLMS, _CLMS, _SABT, _PSMCB, _PSMCBr, _PSM, _SPUB, _DDS],
+    [
+        0,
+        0,
+        0,
+        1,
+        1,
+        () => TargetTrackingConfigurations,
+        () => PredefinedLoadMetricSpecification,
+        () => CustomizedLoadMetricSpecification,
+        1,
+        0,
+        1,
+        0,
+        0,
+        2,
+    ],
+];
+var ScalingPlan = [
+    3,
+    n0,
+    _SPc,
+    0,
+    [_SPN, _SPV, _AS, _SI, _SC, _SM, _SST, _CT],
+    [0, 1, () => ApplicationSource, () => ScalingInstructions, 0, 0, 4, 4],
+];
+var ScalingPlanResource = [
+    3,
+    n0,
+    _SPRc,
+    0,
+    [_SPN, _SPV, _SN, _RI, _SD, _SPca, _SSC, _SSM],
+    [0, 1, 0, 0, 0, () => ScalingPolicies, 0, 0],
+];
+var ScalingPolicy = [
+    3,
+    n0,
+    _SPcal,
+    0,
+    [_PN, _PT, _TTCa],
+    [0, 0, () => TargetTrackingConfiguration],
+];
+var TagFilter = [3, n0, _TFa, 0, [_K, _Va], [0, 64 | 0]];
+var TargetTrackingConfiguration = [
+    3,
+    n0,
+    _TTCa,
+    0,
+    [_PSMS, _CSMS, _TV, _DSI, _SOC, _SIC, _EIW],
+    [() => PredefinedScalingMetricSpecification, () => CustomizedScalingMetricSpecification, 1, 2, 1, 1, 1],
+];
+var UpdateScalingPlanRequest = [
+    3,
+    n0,
+    _USPR,
+    0,
+    [_SPN, _SPV, _AS, _SI],
+    [0, 1, () => ApplicationSource, () => ScalingInstructions],
+];
+var UpdateScalingPlanResponse = [3, n0, _USPRp, 0, [], []];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`ValidationException`, 400],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var AutoScalingPlansServiceException = [
+    -3,
+    _sm,
+    "AutoScalingPlansServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(AutoScalingPlansServiceException, AutoScalingPlansServiceException$1);
+var ApplicationSources = [1, n0, _ASp, 0, () => ApplicationSource];
+var Datapoints = [1, n0, _Dat, 0, () => Datapoint];
+var MetricDimensions = [1, n0, _MDe, 0, () => MetricDimension];
+var ScalingInstructions = [1, n0, _SI, 0, () => ScalingInstruction];
+var ScalingPlanResources = [1, n0, _SPR, 0, () => ScalingPlanResource];
+var ScalingPlans = [1, n0, _SP, 0, () => ScalingPlan];
+var ScalingPolicies = [1, n0, _SPca, 0, () => ScalingPolicy];
+var TagFilters = [1, n0, _TF, 0, () => TagFilter];
+var TargetTrackingConfigurations = [1, n0, _TTC, 0, () => TargetTrackingConfiguration];
+var CreateScalingPlan = [
+    9,
+    n0,
+    _CSP,
+    0,
+    () => CreateScalingPlanRequest,
+    () => CreateScalingPlanResponse,
+];
+var DeleteScalingPlan = [
+    9,
+    n0,
+    _DSP,
+    0,
+    () => DeleteScalingPlanRequest,
+    () => DeleteScalingPlanResponse,
+];
+var DescribeScalingPlanResources = [
+    9,
+    n0,
+    _DSPRescr,
+    0,
+    () => DescribeScalingPlanResourcesRequest,
+    () => DescribeScalingPlanResourcesResponse,
+];
+var DescribeScalingPlans = [
+    9,
+    n0,
+    _DSPe,
+    0,
+    () => DescribeScalingPlansRequest,
+    () => DescribeScalingPlansResponse,
+];
+var GetScalingPlanResourceForecastData = [
+    9,
+    n0,
+    _GSPRFD,
+    0,
+    () => GetScalingPlanResourceForecastDataRequest,
+    () => GetScalingPlanResourceForecastDataResponse,
+];
+var UpdateScalingPlan = [
+    9,
+    n0,
+    _USP,
+    0,
+    () => UpdateScalingPlanRequest,
+    () => UpdateScalingPlanResponse,
+];
 
 class CreateScalingPlanCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AnyScaleScalingPlannerFrontendService", "CreateScalingPlan", {})
     .n("AutoScalingPlansClient", "CreateScalingPlanCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateScalingPlanCommand)
-    .de(de_CreateScalingPlanCommand)
+    .sc(CreateScalingPlan)
     .build() {
 }
 
@@ -737,16 +690,11 @@ class DeleteScalingPlanCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AnyScaleScalingPlannerFrontendService", "DeleteScalingPlan", {})
     .n("AutoScalingPlansClient", "DeleteScalingPlanCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteScalingPlanCommand)
-    .de(de_DeleteScalingPlanCommand)
+    .sc(DeleteScalingPlan)
     .build() {
 }
 
@@ -754,16 +702,11 @@ class DescribeScalingPlanResourcesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AnyScaleScalingPlannerFrontendService", "DescribeScalingPlanResources", {})
     .n("AutoScalingPlansClient", "DescribeScalingPlanResourcesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeScalingPlanResourcesCommand)
-    .de(de_DescribeScalingPlanResourcesCommand)
+    .sc(DescribeScalingPlanResources)
     .build() {
 }
 
@@ -771,16 +714,11 @@ class DescribeScalingPlansCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AnyScaleScalingPlannerFrontendService", "DescribeScalingPlans", {})
     .n("AutoScalingPlansClient", "DescribeScalingPlansCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeScalingPlansCommand)
-    .de(de_DescribeScalingPlansCommand)
+    .sc(DescribeScalingPlans)
     .build() {
 }
 
@@ -788,16 +726,11 @@ class GetScalingPlanResourceForecastDataCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AnyScaleScalingPlannerFrontendService", "GetScalingPlanResourceForecastData", {})
     .n("AutoScalingPlansClient", "GetScalingPlanResourceForecastDataCommand")
-    .f(void 0, void 0)
-    .ser(se_GetScalingPlanResourceForecastDataCommand)
-    .de(de_GetScalingPlanResourceForecastDataCommand)
+    .sc(GetScalingPlanResourceForecastData)
     .build() {
 }
 
@@ -805,16 +738,11 @@ class UpdateScalingPlanCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AnyScaleScalingPlannerFrontendService", "UpdateScalingPlan", {})
     .n("AutoScalingPlansClient", "UpdateScalingPlanCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateScalingPlanCommand)
-    .de(de_UpdateScalingPlanCommand)
+    .sc(UpdateScalingPlan)
     .build() {
 }
 
@@ -840,20 +768,20 @@ Object.defineProperty(exports, "__Client", {
 });
 exports.AutoScalingPlans = AutoScalingPlans;
 exports.AutoScalingPlansClient = AutoScalingPlansClient;
-exports.AutoScalingPlansServiceException = AutoScalingPlansServiceException;
-exports.ConcurrentUpdateException = ConcurrentUpdateException;
+exports.AutoScalingPlansServiceException = AutoScalingPlansServiceException$1;
+exports.ConcurrentUpdateException = ConcurrentUpdateException$1;
 exports.CreateScalingPlanCommand = CreateScalingPlanCommand;
 exports.DeleteScalingPlanCommand = DeleteScalingPlanCommand;
 exports.DescribeScalingPlanResourcesCommand = DescribeScalingPlanResourcesCommand;
 exports.DescribeScalingPlansCommand = DescribeScalingPlansCommand;
 exports.ForecastDataType = ForecastDataType;
 exports.GetScalingPlanResourceForecastDataCommand = GetScalingPlanResourceForecastDataCommand;
-exports.InternalServiceException = InternalServiceException;
-exports.InvalidNextTokenException = InvalidNextTokenException;
-exports.LimitExceededException = LimitExceededException;
+exports.InternalServiceException = InternalServiceException$1;
+exports.InvalidNextTokenException = InvalidNextTokenException$1;
+exports.LimitExceededException = LimitExceededException$1;
 exports.LoadMetricType = LoadMetricType;
 exports.MetricStatistic = MetricStatistic;
-exports.ObjectNotFoundException = ObjectNotFoundException;
+exports.ObjectNotFoundException = ObjectNotFoundException$1;
 exports.PolicyType = PolicyType;
 exports.PredictiveScalingMaxCapacityBehavior = PredictiveScalingMaxCapacityBehavior;
 exports.PredictiveScalingMode = PredictiveScalingMode;
@@ -864,4 +792,4 @@ exports.ScalingPolicyUpdateBehavior = ScalingPolicyUpdateBehavior;
 exports.ScalingStatusCode = ScalingStatusCode;
 exports.ServiceNamespace = ServiceNamespace;
 exports.UpdateScalingPlanCommand = UpdateScalingPlanCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;