@aws-sdk/client-arc-region-switch 3.927.0 → 3.928.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');
 var utilWaiter = require('@smithy/util-waiter');
 
 const resolveClientEndpointParameters = (options) => {
@@ -90,6 +89,7 @@ class ARCRegionSwitchClient 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));
@@ -109,12 +109,12 @@ class ARCRegionSwitchClient extends smithyClient.Client {
     }
 }
 
-class ARCRegionSwitchServiceException extends smithyClient.ServiceException {
+let ARCRegionSwitchServiceException$1 = class ARCRegionSwitchServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, ARCRegionSwitchServiceException.prototype);
     }
-}
+};
 
 const ExecutionAction = {
     ACTIVATE: "activate",
@@ -141,7 +141,7 @@ const RecoveryApproach = {
     ACTIVE_ACTIVE: "activeActive",
     ACTIVE_PASSIVE: "activePassive",
 };
-class AccessDeniedException extends ARCRegionSwitchServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends ARCRegionSwitchServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -152,7 +152,7 @@ class AccessDeniedException extends ARCRegionSwitchServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
+};
 const AlarmCondition = {
     GREEN: "green",
     RED: "red",
@@ -165,7 +165,7 @@ const Approval = {
     APPROVE: "approve",
     DECLINE: "decline",
 };
-class ResourceNotFoundException extends ARCRegionSwitchServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends ARCRegionSwitchServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -176,7 +176,7 @@ class ResourceNotFoundException extends ARCRegionSwitchServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
+};
 const EvaluationStatus = {
     ACTION_REQUIRED: "actionRequired",
     PASSED: "passed",
@@ -268,7 +268,7 @@ const ExecutionEventType = {
     STEP_UPDATE: "stepUpdate",
     UNKNOWN: "unknown",
 };
-class InternalServerException extends ARCRegionSwitchServiceException {
+let InternalServerException$1 = class InternalServerException extends ARCRegionSwitchServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     constructor(opts) {
@@ -279,8 +279,8 @@ class InternalServerException extends ARCRegionSwitchServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class IllegalStateException extends ARCRegionSwitchServiceException {
+};
+let IllegalStateException$1 = class IllegalStateException extends ARCRegionSwitchServiceException$1 {
     name = "IllegalStateException";
     $fault = "client";
     constructor(opts) {
@@ -291,8 +291,8 @@ class IllegalStateException extends ARCRegionSwitchServiceException {
         });
         Object.setPrototypeOf(this, IllegalStateException.prototype);
     }
-}
-class IllegalArgumentException extends ARCRegionSwitchServiceException {
+};
+let IllegalArgumentException$1 = class IllegalArgumentException extends ARCRegionSwitchServiceException$1 {
     name = "IllegalArgumentException";
     $fault = "client";
     constructor(opts) {
@@ -303,7 +303,7 @@ class IllegalArgumentException extends ARCRegionSwitchServiceException {
         });
         Object.setPrototypeOf(this, IllegalArgumentException.prototype);
     }
-}
+};
 const UpdatePlanExecutionAction = {
     PAUSE: "pause",
     RESUME: "resume",
@@ -341,888 +341,755 @@ exports.ExecutionBlockConfiguration = void 0;
     };
 })(exports.ExecutionBlockConfiguration || (exports.ExecutionBlockConfiguration = {}));
 
-const se_ApprovePlanExecutionStepCommand = async (input, context) => {
-    const headers = sharedHeaders("ApprovePlanExecutionStep");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CancelPlanExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("CancelPlanExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreatePlanCommand = async (input, context) => {
-    const headers = sharedHeaders("CreatePlan");
-    let body;
-    body = JSON.stringify(se_CreatePlanRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeletePlanCommand = async (input, context) => {
-    const headers = sharedHeaders("DeletePlan");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetPlanCommand = async (input, context) => {
-    const headers = sharedHeaders("GetPlan");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetPlanEvaluationStatusCommand = async (input, context) => {
-    const headers = sharedHeaders("GetPlanEvaluationStatus");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetPlanExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("GetPlanExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetPlanInRegionCommand = async (input, context) => {
-    const headers = sharedHeaders("GetPlanInRegion");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListPlanExecutionEventsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListPlanExecutionEvents");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListPlanExecutionsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListPlanExecutions");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListPlansCommand = async (input, context) => {
-    const headers = sharedHeaders("ListPlans");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListPlansInRegionCommand = async (input, context) => {
-    const headers = sharedHeaders("ListPlansInRegion");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListRoute53HealthChecksCommand = async (input, context) => {
-    const headers = sharedHeaders("ListRoute53HealthChecks");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_StartPlanExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("StartPlanExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("TagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdatePlanCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdatePlan");
-    let body;
-    body = JSON.stringify(se_UpdatePlanRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdatePlanExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdatePlanExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdatePlanExecutionStepCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdatePlanExecutionStep");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_ApprovePlanExecutionStepCommand = 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_CancelPlanExecutionCommand = 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_CreatePlanCommand = 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_CreatePlanResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeletePlanCommand = 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_GetPlanCommand = 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_GetPlanResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetPlanEvaluationStatusCommand = 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_GetPlanEvaluationStatusResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetPlanExecutionCommand = 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_GetPlanExecutionResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetPlanInRegionCommand = 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_GetPlanInRegionResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListPlanExecutionEventsCommand = 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_ListPlanExecutionEventsResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListPlanExecutionsCommand = 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_ListPlanExecutionsResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListPlansCommand = 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_ListPlansResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListPlansInRegionCommand = 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_ListPlansInRegionResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListRoute53HealthChecksCommand = 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_ListTagsForResourceCommand = 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_StartPlanExecutionCommand = 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_TagResourceCommand = 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_UntagResourceCommand = 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_UpdatePlanCommand = 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_UpdatePlanResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdatePlanExecutionCommand = 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_UpdatePlanExecutionStepCommand = 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 "AccessDeniedException":
-        case "com.amazonaws.arcregionswitch#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.arcregionswitch#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "IllegalStateException":
-        case "com.amazonaws.arcregionswitch#IllegalStateException":
-            throw await de_IllegalStateExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.arcregionswitch#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "IllegalArgumentException":
-        case "com.amazonaws.arcregionswitch#IllegalArgumentException":
-            throw await de_IllegalArgumentExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_IllegalArgumentExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new IllegalArgumentException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_IllegalStateExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new IllegalStateException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_CreatePlanRequest = (input, context) => {
-    return smithyClient.take(input, {
-        associatedAlarms: smithyClient._json,
-        description: [],
-        executionRole: [],
-        name: [],
-        primaryRegion: [],
-        recoveryApproach: [],
-        recoveryTimeObjectiveMinutes: [],
-        regions: smithyClient._json,
-        tags: smithyClient._json,
-        triggers: smithyClient._json,
-        workflows: (_) => se_WorkflowList(_),
-    });
-};
-const se_CustomActionLambdaConfiguration = (input, context) => {
-    return smithyClient.take(input, {
-        lambdas: smithyClient._json,
-        regionToRun: [],
-        retryIntervalMinutes: smithyClient.serializeFloat,
-        timeoutMinutes: [],
-        ungraceful: smithyClient._json,
-    });
-};
-const se_ExecutionBlockConfiguration = (input, context) => {
-    return exports.ExecutionBlockConfiguration.visit(input, {
-        arcRoutingControlConfig: (value) => ({ arcRoutingControlConfig: smithyClient._json(value) }),
-        customActionLambdaConfig: (value) => ({
-            customActionLambdaConfig: se_CustomActionLambdaConfiguration(value),
-        }),
-        ec2AsgCapacityIncreaseConfig: (value) => ({ ec2AsgCapacityIncreaseConfig: smithyClient._json(value) }),
-        ecsCapacityIncreaseConfig: (value) => ({ ecsCapacityIncreaseConfig: smithyClient._json(value) }),
-        eksResourceScalingConfig: (value) => ({ eksResourceScalingConfig: smithyClient._json(value) }),
-        executionApprovalConfig: (value) => ({ executionApprovalConfig: smithyClient._json(value) }),
-        globalAuroraConfig: (value) => ({ globalAuroraConfig: smithyClient._json(value) }),
-        parallelConfig: (value) => ({ parallelConfig: se_ParallelExecutionBlockConfiguration(value) }),
-        regionSwitchPlanConfig: (value) => ({ regionSwitchPlanConfig: smithyClient._json(value) }),
-        route53HealthCheckConfig: (value) => ({ route53HealthCheckConfig: smithyClient._json(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_ParallelExecutionBlockConfiguration = (input, context) => {
-    return smithyClient.take(input, {
-        steps: (_) => se_Steps(_),
-    });
-};
-const se_Step = (input, context) => {
-    return smithyClient.take(input, {
-        description: [],
-        executionBlockConfiguration: (_) => se_ExecutionBlockConfiguration(_),
-        executionBlockType: [],
-        name: [],
-    });
-};
-const se_Steps = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_Step(entry);
-    });
-};
-const se_UpdatePlanRequest = (input, context) => {
-    return smithyClient.take(input, {
-        arn: [],
-        associatedAlarms: smithyClient._json,
-        description: [],
-        executionRole: [],
-        recoveryTimeObjectiveMinutes: [],
-        triggers: smithyClient._json,
-        workflows: (_) => se_WorkflowList(_),
-    });
-};
-const se_Workflow = (input, context) => {
-    return smithyClient.take(input, {
-        steps: (_) => se_Steps(_),
-        workflowDescription: [],
-        workflowTargetAction: [],
-        workflowTargetRegion: [],
-    });
-};
-const se_WorkflowList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_Workflow(entry);
-    });
-};
-const de_AbbreviatedExecution = (output, context) => {
-    return smithyClient.take(output, {
-        actualRecoveryTime: smithyClient.expectString,
-        comment: smithyClient.expectString,
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        executionAction: smithyClient.expectString,
-        executionId: smithyClient.expectString,
-        executionRegion: smithyClient.expectString,
-        executionState: smithyClient.expectString,
-        mode: smithyClient.expectString,
-        planArn: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        version: smithyClient.expectString,
-    });
-};
-const de_AbbreviatedExecutionsList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AbbreviatedExecution(entry);
-    });
-    return retVal;
-};
-const de_AbbreviatedPlan = (output, context) => {
-    return smithyClient.take(output, {
-        activePlanExecution: smithyClient.expectString,
-        arn: smithyClient.expectString,
-        description: smithyClient.expectString,
-        executionRole: smithyClient.expectString,
-        name: smithyClient.expectString,
-        owner: smithyClient.expectString,
-        primaryRegion: smithyClient.expectString,
-        recoveryApproach: smithyClient.expectString,
-        recoveryTimeObjectiveMinutes: smithyClient.expectInt32,
-        regions: smithyClient._json,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        version: smithyClient.expectString,
-    });
-};
-const de_CreatePlanResponse = (output, context) => {
-    return smithyClient.take(output, {
-        plan: (_) => de_Plan(_),
-    });
-};
-const de_CustomActionLambdaConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        lambdas: smithyClient._json,
-        regionToRun: smithyClient.expectString,
-        retryIntervalMinutes: smithyClient.limitedParseFloat32,
-        timeoutMinutes: smithyClient.expectInt32,
-        ungraceful: smithyClient._json,
-    });
-};
-const de_ExecutionBlockConfiguration = (output, context) => {
-    if (output.arcRoutingControlConfig != null) {
-        return {
-            arcRoutingControlConfig: smithyClient._json(output.arcRoutingControlConfig),
-        };
-    }
-    if (output.customActionLambdaConfig != null) {
-        return {
-            customActionLambdaConfig: de_CustomActionLambdaConfiguration(output.customActionLambdaConfig),
-        };
-    }
-    if (output.ec2AsgCapacityIncreaseConfig != null) {
-        return {
-            ec2AsgCapacityIncreaseConfig: smithyClient._json(output.ec2AsgCapacityIncreaseConfig),
-        };
-    }
-    if (output.ecsCapacityIncreaseConfig != null) {
-        return {
-            ecsCapacityIncreaseConfig: smithyClient._json(output.ecsCapacityIncreaseConfig),
-        };
-    }
-    if (output.eksResourceScalingConfig != null) {
-        return {
-            eksResourceScalingConfig: smithyClient._json(output.eksResourceScalingConfig),
-        };
-    }
-    if (output.executionApprovalConfig != null) {
-        return {
-            executionApprovalConfig: smithyClient._json(output.executionApprovalConfig),
-        };
-    }
-    if (output.globalAuroraConfig != null) {
-        return {
-            globalAuroraConfig: smithyClient._json(output.globalAuroraConfig),
-        };
-    }
-    if (output.parallelConfig != null) {
-        return {
-            parallelConfig: de_ParallelExecutionBlockConfiguration(output.parallelConfig),
-        };
-    }
-    if (output.regionSwitchPlanConfig != null) {
-        return {
-            regionSwitchPlanConfig: smithyClient._json(output.regionSwitchPlanConfig),
-        };
-    }
-    if (output.route53HealthCheckConfig != null) {
-        return {
-            route53HealthCheckConfig: smithyClient._json(output.route53HealthCheckConfig),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_ExecutionEvent = (output, context) => {
-    return smithyClient.take(output, {
-        description: smithyClient.expectString,
-        error: smithyClient.expectString,
-        eventId: smithyClient.expectString,
-        executionBlockType: smithyClient.expectString,
-        previousEventId: smithyClient.expectString,
-        resources: smithyClient._json,
-        stepName: smithyClient.expectString,
-        timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        type: smithyClient.expectString,
-    });
-};
-const de_ExecutionEventList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ExecutionEvent(entry);
-    });
-    return retVal;
-};
-const de_GetPlanEvaluationStatusResponse = (output, context) => {
-    return smithyClient.take(output, {
-        evaluationState: smithyClient.expectString,
-        lastEvaluatedVersion: smithyClient.expectString,
-        lastEvaluationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        nextToken: smithyClient.expectString,
-        planArn: smithyClient.expectString,
-        region: smithyClient.expectString,
-        warnings: (_) => de_PlanWarnings(_),
-    });
-};
-const de_GetPlanExecutionResponse = (output, context) => {
-    return smithyClient.take(output, {
-        actualRecoveryTime: smithyClient.expectString,
-        comment: smithyClient.expectString,
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        executionAction: smithyClient.expectString,
-        executionId: smithyClient.expectString,
-        executionRegion: smithyClient.expectString,
-        executionState: smithyClient.expectString,
-        mode: smithyClient.expectString,
-        nextToken: smithyClient.expectString,
-        plan: (_) => de_Plan(_),
-        planArn: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stepStates: (_) => de_StepStates(_),
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        version: smithyClient.expectString,
-    });
-};
-const de_GetPlanInRegionResponse = (output, context) => {
-    return smithyClient.take(output, {
-        plan: (_) => de_Plan(_),
-    });
-};
-const de_GetPlanResponse = (output, context) => {
-    return smithyClient.take(output, {
-        plan: (_) => de_Plan(_),
-    });
-};
-const de_ListPlanExecutionEventsResponse = (output, context) => {
-    return smithyClient.take(output, {
-        items: (_) => de_ExecutionEventList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_ListPlanExecutionsResponse = (output, context) => {
-    return smithyClient.take(output, {
-        items: (_) => de_AbbreviatedExecutionsList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_ListPlansInRegionResponse = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        plans: (_) => de_PlanList(_),
-    });
-};
-const de_ListPlansResponse = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        plans: (_) => de_PlanList(_),
-    });
-};
-const de_ParallelExecutionBlockConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        steps: (_) => de_Steps(_),
-    });
-};
-const de_Plan = (output, context) => {
-    return smithyClient.take(output, {
-        arn: smithyClient.expectString,
-        associatedAlarms: smithyClient._json,
-        description: smithyClient.expectString,
-        executionRole: smithyClient.expectString,
-        name: smithyClient.expectString,
-        owner: smithyClient.expectString,
-        primaryRegion: smithyClient.expectString,
-        recoveryApproach: smithyClient.expectString,
-        recoveryTimeObjectiveMinutes: smithyClient.expectInt32,
-        regions: smithyClient._json,
-        triggers: smithyClient._json,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        version: smithyClient.expectString,
-        workflows: (_) => de_WorkflowList(_),
-    });
-};
-const de_PlanList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AbbreviatedPlan(entry);
-    });
-    return retVal;
-};
-const de_PlanWarnings = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ResourceWarning(entry);
-    });
-    return retVal;
-};
-const de_ResourceWarning = (output, context) => {
-    return smithyClient.take(output, {
-        resourceArn: smithyClient.expectString,
-        stepName: smithyClient.expectString,
-        version: smithyClient.expectString,
-        warningMessage: smithyClient.expectString,
-        warningStatus: smithyClient.expectString,
-        warningUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        workflow: smithyClient._json,
-    });
-};
-const de_Step = (output, context) => {
-    return smithyClient.take(output, {
-        description: smithyClient.expectString,
-        executionBlockConfiguration: (_) => de_ExecutionBlockConfiguration(core$1.awsExpectUnion(_)),
-        executionBlockType: smithyClient.expectString,
-        name: smithyClient.expectString,
-    });
-};
-const de_Steps = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Step(entry);
-    });
-    return retVal;
-};
-const de_StepState = (output, context) => {
-    return smithyClient.take(output, {
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        name: smithyClient.expectString,
-        startTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-        stepMode: smithyClient.expectString,
-    });
-};
-const de_StepStates = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StepState(entry);
-    });
-    return retVal;
-};
-const de_UpdatePlanResponse = (output, context) => {
-    return smithyClient.take(output, {
-        plan: (_) => de_Plan(_),
-    });
-};
-const de_Workflow = (output, context) => {
-    return smithyClient.take(output, {
-        steps: (_) => de_Steps(_),
-        workflowDescription: smithyClient.expectString,
-        workflowTargetAction: smithyClient.expectString,
-        workflowTargetRegion: smithyClient.expectString,
-    });
-};
-const de_WorkflowList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Workflow(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(ARCRegionSwitchServiceException);
-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.0",
-        "x-amz-target": `ArcRegionSwitch.${operation}`,
-    };
-}
+const _A = "Asg";
+const _AA = "AssociatedAlarm";
+const _AAM = "AssociatedAlarmMap";
+const _ADE = "AccessDeniedException";
+const _AE = "AbbreviatedExecution";
+const _AEL = "AbbreviatedExecutionsList";
+const _AL = "AsgList";
+const _AP = "AbbreviatedPlan";
+const _APES = "ApprovePlanExecutionStep";
+const _APESR = "ApprovePlanExecutionStepRequest";
+const _APESRp = "ApprovePlanExecutionStepResponse";
+const _ARCC = "ArcRoutingControlConfiguration";
+const _ARCS = "ArcRoutingControlState";
+const _ARCSr = "ArcRoutingControlStates";
+const _CALC = "CustomActionLambdaConfiguration";
+const _CP = "CreatePlan";
+const _CPE = "CancelPlanExecution";
+const _CPER = "CancelPlanExecutionRequest";
+const _CPERa = "CancelPlanExecutionResponse";
+const _CPR = "CreatePlanRequest";
+const _CPRr = "CreatePlanResponse";
+const _DP = "DeletePlan";
+const _DPR = "DeletePlanRequest";
+const _DPRe = "DeletePlanResponse";
+const _EAC = "ExecutionApprovalConfiguration";
+const _EACIC = "Ec2AsgCapacityIncreaseConfiguration";
+const _EBC = "ExecutionBlockConfiguration";
+const _EC = "EksCluster";
+const _ECIC = "EcsCapacityIncreaseConfiguration";
+const _ECk = "EksClusters";
+const _EE = "ExecutionEvent";
+const _EEL = "ExecutionEventList";
+const _ERSC = "EksResourceScalingConfiguration";
+const _ERSU = "EksResourceScalingUngraceful";
+const _EU = "Ec2Ungraceful";
+const _EUc = "EcsUngraceful";
+const _GAC = "GlobalAuroraConfiguration";
+const _GAU = "GlobalAuroraUngraceful";
+const _GP = "GetPlan";
+const _GPE = "GetPlanExecution";
+const _GPER = "GetPlanExecutionRequest";
+const _GPERe = "GetPlanExecutionResponse";
+const _GPES = "GetPlanEvaluationStatus";
+const _GPESR = "GetPlanEvaluationStatusRequest";
+const _GPESRe = "GetPlanEvaluationStatusResponse";
+const _GPIR = "GetPlanInRegion";
+const _GPIRR = "GetPlanInRegionRequest";
+const _GPIRRe = "GetPlanInRegionResponse";
+const _GPR = "GetPlanRequest";
+const _GPRe = "GetPlanResponse";
+const _IAE = "IllegalArgumentException";
+const _ISE = "IllegalStateException";
+const _ISEn = "InternalServerException";
+const _KRT = "KubernetesResourceType";
+const _KSA = "KubernetesScalingApps";
+const _KSAu = "KubernetesScalingApplication";
+const _KSR = "KubernetesScalingResource";
+const _L = "Lambdas";
+const _LL = "LambdaList";
+const _LP = "ListPlans";
+const _LPE = "ListPlanExecutions";
+const _LPEE = "ListPlanExecutionEvents";
+const _LPEER = "ListPlanExecutionEventsRequest";
+const _LPEERi = "ListPlanExecutionEventsResponse";
+const _LPER = "ListPlanExecutionsRequest";
+const _LPERi = "ListPlanExecutionsResponse";
+const _LPIR = "ListPlansInRegion";
+const _LPIRR = "ListPlansInRegionRequest";
+const _LPIRRi = "ListPlansInRegionResponse";
+const _LPR = "ListPlansRequest";
+const _LPRi = "ListPlansResponse";
+const _LRHC = "ListRoute53HealthChecks";
+const _LRHCR = "ListRoute53HealthChecksRequest";
+const _LRHCRi = "ListRoute53HealthChecksResponse";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _LU = "LambdaUngraceful";
+const _MW = "MinimalWorkflow";
+const _P = "Plan";
+const _PEBC = "ParallelExecutionBlockConfiguration";
+const _PL = "PlanList";
+const _PW = "PlanWarnings";
+const _RARC = "RegionAndRoutingControls";
+const _RHC = "Route53HealthCheck";
+const _RHCC = "Route53HealthCheckConfiguration";
+const _RHCL = "Route53HealthCheckList";
+const _RNFE = "ResourceNotFoundException";
+const _RRRS = "Route53ResourceRecordSet";
+const _RRRSL = "Route53ResourceRecordSetList";
+const _RSPC = "RegionSwitchPlanConfiguration";
+const _RSR = "RegionalScalingResource";
+const _RW = "ResourceWarning";
+const _S = "Service";
+const _SL = "ServiceList";
+const _SPE = "StartPlanExecution";
+const _SPER = "StartPlanExecutionRequest";
+const _SPERt = "StartPlanExecutionResponse";
+const _SS = "StepState";
+const _SSt = "StepStates";
+const _St = "Step";
+const _Ste = "Steps";
+const _T = "Trigger";
+const _TC = "TriggerCondition";
+const _TCL = "TriggerConditionList";
+const _TL = "TriggerList";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UP = "UpdatePlan";
+const _UPE = "UpdatePlanExecution";
+const _UPER = "UpdatePlanExecutionRequest";
+const _UPERp = "UpdatePlanExecutionResponse";
+const _UPES = "UpdatePlanExecutionStep";
+const _UPESR = "UpdatePlanExecutionStepRequest";
+const _UPESRp = "UpdatePlanExecutionStepResponse";
+const _UPR = "UpdatePlanRequest";
+const _UPRp = "UpdatePlanResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _W = "Workflow";
+const _WL = "WorkflowList";
+const _a = "arn";
+const _aA = "associatedAlarms";
+const _aAN = "associatedAlarmName";
+const _aPE = "activePlanExecution";
+const _aR = "approvalRole";
+const _aRCC = "arcRoutingControlConfig";
+const _aRT = "actualRecoveryTime";
+const _aRc = "activateRegion";
+const _aT = "alarmType";
+const _aTT = "actionToTake";
+const _aV = "apiVersion";
+const _ac = "action";
+const _ap = "approval";
+const _as = "asgs";
+const _b = "behavior";
+const _c = "comment";
+const _cA = "clusterArn";
+const _cALC = "customActionLambdaConfig";
+const _cAR = "crossAccountRole";
+const _cMA = "capacityMonitoringApproach";
+const _cl = "client";
+const _co = "conditions";
+const _con = "condition";
+const _d = "description";
+const _dCA = "databaseClusterArns";
+const _dR = "deactivateRegion";
+const _e = "error";
+const _eA = "executionAction";
+const _eAC = "executionApprovalConfig";
+const _eACIC = "ec2AsgCapacityIncreaseConfig";
+const _eBC = "executionBlockConfiguration";
+const _eBT = "executionBlockType";
+const _eC = "eksClusters";
+const _eCIC = "ecsCapacityIncreaseConfig";
+const _eI = "executionId";
+const _eIv = "eventId";
+const _eIx = "externalId";
+const _eR = "executionRegion";
+const _eRSC = "eksResourceScalingConfig";
+const _eRx = "executionRole";
+const _eS = "executionState";
+const _eSv = "evaluationState";
+const _eT = "endTime";
+const _gAC = "globalAuroraConfig";
+const _gCI = "globalClusterIdentifier";
+const _hC = "healthChecks";
+const _hCI = "healthCheckId";
+const _hE = "httpError";
+const _hN = "hpaName";
+const _hZI = "hostedZoneId";
+const _i = "items";
+const _k = "kind";
+const _kRT = "kubernetesResourceType";
+const _l = "lambdas";
+const _lET = "lastEvaluationTime";
+const _lEV = "lastEvaluatedVersion";
+const _lV = "latestVersion";
+const _m = "mode";
+const _mDMBE = "minDelayMinutesBetweenExecutions";
+const _mR = "maxResults";
+const _mSP = "minimumSuccessPercentage";
+const _me = "message";
+const _n = "name";
+const _nT = "nextToken";
+const _na = "namespace";
+const _o = "owner";
+const _p = "plan";
+const _pA = "planArn";
+const _pC = "parallelConfig";
+const _pEI = "previousEventId";
+const _pR = "primaryRegion";
+const _pV = "planVersion";
+const _pl = "plans";
+const _r = "regions";
+const _rA = "recoveryApproach";
+const _rARC = "regionAndRoutingControls";
+const _rAe = "resourceArn";
+const _rCA = "routingControlArn";
+const _rHCC = "route53HealthCheckConfig";
+const _rI = "resourceIdentifier";
+const _rIM = "retryIntervalMinutes";
+const _rN = "recordName";
+const _rS = "recordSets";
+const _rSI = "recordSetIdentifier";
+const _rSPC = "regionSwitchPlanConfig";
+const _rT = "resourceTags";
+const _rTK = "resourceTagKeys";
+const _rTOM = "recoveryTimeObjectiveMinutes";
+const _rTR = "regionToRun";
+const _re = "resources";
+const _reg = "region";
+const _s = "state";
+const _sA = "serviceArn";
+const _sM = "stepMode";
+const _sN = "stepName";
+const _sR = "scalingResources";
+const _sS = "stepStates";
+const _sT = "startTime";
+const _se = "services";
+const _ser = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.arcregionswitch";
+const _st = "steps";
+const _sta = "status";
+const _t = "triggers";
+const _tM = "timeoutMinutes";
+const _tP = "targetPercent";
+const _tR = "targetRegion";
+const _ta = "tags";
+const _ti = "timestamp";
+const _ty = "type";
+const _u = "ungraceful";
+const _uA = "updatedAt";
+const _v = "version";
+const _w = "workflows";
+const _wD = "workflowDescription";
+const _wM = "warningMessage";
+const _wS = "warningStatus";
+const _wTA = "workflowTargetAction";
+const _wTR = "workflowTargetRegion";
+const _wUT = "warningUpdatedTime";
+const _wa = "warnings";
+const _wo = "workflow";
+const n0 = "com.amazonaws.arcregionswitch";
+var AbbreviatedExecution = [
+    3,
+    n0,
+    _AE,
+    0,
+    [_pA, _eI, _v, _uA, _c, _sT, _eT, _m, _eS, _eA, _eR, _aRT],
+    [0, 0, 0, 4, 0, 4, 4, 0, 0, 0, 0, 0],
+];
+var AbbreviatedPlan = [
+    3,
+    n0,
+    _AP,
+    0,
+    [_a, _o, _n, _r, _rA, _pR, _v, _uA, _d, _eRx, _aPE, _rTOM],
+    [0, 0, 0, 64 | 0, 0, 0, 0, 4, 0, 0, 0, 1],
+];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _cl,
+        [_hE]: 403,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var ApprovePlanExecutionStepRequest = [
+    3,
+    n0,
+    _APESR,
+    0,
+    [_pA, _eI, _sN, _ap, _c],
+    [0, 0, 0, 0, 0],
+];
+var ApprovePlanExecutionStepResponse = [3, n0, _APESRp, 0, [], []];
+var ArcRoutingControlConfiguration = [
+    3,
+    n0,
+    _ARCC,
+    0,
+    [_tM, _cAR, _eIx, _rARC],
+    [1, 0, 0, () => RegionAndRoutingControls],
+];
+var ArcRoutingControlState = [3, n0, _ARCS, 0, [_rCA, _s], [0, 0]];
+var Asg = [3, n0, _A, 0, [_cAR, _eIx, _a], [0, 0, 0]];
+var AssociatedAlarm = [3, n0, _AA, 0, [_cAR, _eIx, _rI, _aT], [0, 0, 0, 0]];
+var CancelPlanExecutionRequest = [3, n0, _CPER, 0, [_pA, _eI, _c], [0, 0, 0]];
+var CancelPlanExecutionResponse = [3, n0, _CPERa, 0, [], []];
+var CreatePlanRequest = [
+    3,
+    n0,
+    _CPR,
+    0,
+    [_d, _w, _eRx, _rTOM, _aA, _t, _n, _r, _rA, _pR, _ta],
+    [0, () => WorkflowList, 0, 1, () => AssociatedAlarmMap, () => TriggerList, 0, 64 | 0, 0, 0, 128 | 0],
+];
+var CreatePlanResponse = [3, n0, _CPRr, 0, [_p], [() => Plan]];
+var CustomActionLambdaConfiguration = [
+    3,
+    n0,
+    _CALC,
+    0,
+    [_tM, _l, _rIM, _rTR, _u],
+    [1, () => LambdaList, 1, 0, () => LambdaUngraceful],
+];
+var DeletePlanRequest = [3, n0, _DPR, 0, [_a], [0]];
+var DeletePlanResponse = [3, n0, _DPRe, 0, [], []];
+var Ec2AsgCapacityIncreaseConfiguration = [
+    3,
+    n0,
+    _EACIC,
+    0,
+    [_tM, _as, _u, _tP, _cMA],
+    [1, () => AsgList, () => Ec2Ungraceful, 1, 0],
+];
+var Ec2Ungraceful = [3, n0, _EU, 0, [_mSP], [1]];
+var EcsCapacityIncreaseConfiguration = [
+    3,
+    n0,
+    _ECIC,
+    0,
+    [_tM, _se, _u, _tP, _cMA],
+    [1, () => ServiceList, () => EcsUngraceful, 1, 0],
+];
+var EcsUngraceful = [3, n0, _EUc, 0, [_mSP], [1]];
+var EksCluster = [3, n0, _EC, 0, [_cAR, _eIx, _cA], [0, 0, 0]];
+var EksResourceScalingConfiguration = [
+    3,
+    n0,
+    _ERSC,
+    0,
+    [_tM, _kRT, _sR, _eC, _u, _tP, _cMA],
+    [
+        1,
+        () => KubernetesResourceType,
+        () => KubernetesScalingApps,
+        () => EksClusters,
+        () => EksResourceScalingUngraceful,
+        1,
+        0,
+    ],
+];
+var EksResourceScalingUngraceful = [3, n0, _ERSU, 0, [_mSP], [1]];
+var ExecutionApprovalConfiguration = [3, n0, _EAC, 0, [_tM, _aR], [1, 0]];
+var ExecutionEvent = [
+    3,
+    n0,
+    _EE,
+    0,
+    [_ti, _ty, _sN, _eBT, _re, _e, _d, _eIv, _pEI],
+    [4, 0, 0, 0, 64 | 0, 0, 0, 0, 0],
+];
+var GetPlanEvaluationStatusRequest = [3, n0, _GPESR, 0, [_pA, _mR, _nT], [0, 1, 0]];
+var GetPlanEvaluationStatusResponse = [
+    3,
+    n0,
+    _GPESRe,
+    0,
+    [_pA, _lET, _lEV, _reg, _eSv, _wa, _nT],
+    [0, 4, 0, 0, 0, () => PlanWarnings, 0],
+];
+var GetPlanExecutionRequest = [3, n0, _GPER, 0, [_pA, _eI, _mR, _nT], [0, 0, 1, 0]];
+var GetPlanExecutionResponse = [
+    3,
+    n0,
+    _GPERe,
+    0,
+    [_pA, _eI, _v, _uA, _c, _sT, _eT, _m, _eS, _eA, _eR, _sS, _p, _aRT, _nT],
+    [0, 0, 0, 4, 0, 4, 4, 0, 0, 0, 0, () => StepStates, () => Plan, 0, 0],
+];
+var GetPlanInRegionRequest = [3, n0, _GPIRR, 0, [_a], [0]];
+var GetPlanInRegionResponse = [3, n0, _GPIRRe, 0, [_p], [() => Plan]];
+var GetPlanRequest = [3, n0, _GPR, 0, [_a], [0]];
+var GetPlanResponse = [3, n0, _GPRe, 0, [_p], [() => Plan]];
+var GlobalAuroraConfiguration = [
+    3,
+    n0,
+    _GAC,
+    0,
+    [_tM, _cAR, _eIx, _b, _u, _gCI, _dCA],
+    [1, 0, 0, 0, () => GlobalAuroraUngraceful, 0, 64 | 0],
+];
+var GlobalAuroraUngraceful = [3, n0, _GAU, 0, [_u], [0]];
+var IllegalArgumentException = [
+    -3,
+    n0,
+    _IAE,
+    {
+        [_e]: _cl,
+        [_hE]: 400,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(IllegalArgumentException, IllegalArgumentException$1);
+var IllegalStateException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _cl,
+        [_hE]: 400,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(IllegalStateException, IllegalStateException$1);
+var InternalServerException = [
+    -3,
+    n0,
+    _ISEn,
+    {
+        [_e]: _ser,
+        [_hE]: 500,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var KubernetesResourceType = [3, n0, _KRT, 0, [_aV, _k], [0, 0]];
+var KubernetesScalingResource = [3, n0, _KSR, 0, [_na, _n, _hN], [0, 0, 0]];
+var Lambdas = [3, n0, _L, 0, [_cAR, _eIx, _a], [0, 0, 0]];
+var LambdaUngraceful = [3, n0, _LU, 0, [_b], [0]];
+var ListPlanExecutionEventsRequest = [
+    3,
+    n0,
+    _LPEER,
+    0,
+    [_pA, _eI, _mR, _nT, _n],
+    [0, 0, 1, 0, 0],
+];
+var ListPlanExecutionEventsResponse = [
+    3,
+    n0,
+    _LPEERi,
+    0,
+    [_i, _nT],
+    [() => ExecutionEventList, 0],
+];
+var ListPlanExecutionsRequest = [3, n0, _LPER, 0, [_pA, _mR, _nT, _s], [0, 1, 0, 0]];
+var ListPlanExecutionsResponse = [
+    3,
+    n0,
+    _LPERi,
+    0,
+    [_i, _nT],
+    [() => AbbreviatedExecutionsList, 0],
+];
+var ListPlansInRegionRequest = [3, n0, _LPIRR, 0, [_mR, _nT], [1, 0]];
+var ListPlansInRegionResponse = [3, n0, _LPIRRi, 0, [_pl, _nT], [() => PlanList, 0]];
+var ListPlansRequest = [3, n0, _LPR, 0, [_mR, _nT], [1, 0]];
+var ListPlansResponse = [3, n0, _LPRi, 0, [_pl, _nT], [() => PlanList, 0]];
+var ListRoute53HealthChecksRequest = [
+    3,
+    n0,
+    _LRHCR,
+    0,
+    [_a, _hZI, _rN, _mR, _nT],
+    [0, 0, 0, 1, 0],
+];
+var ListRoute53HealthChecksResponse = [
+    3,
+    n0,
+    _LRHCRi,
+    0,
+    [_hC, _nT],
+    [() => Route53HealthCheckList, 0],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_a], [0]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_rT], [128 | 0]];
+var MinimalWorkflow = [3, n0, _MW, 0, [_ac, _n], [0, 0]];
+var ParallelExecutionBlockConfiguration = [3, n0, _PEBC, 0, [_st], [() => Steps]];
+var Plan = [
+    3,
+    n0,
+    _P,
+    0,
+    [_a, _d, _w, _eRx, _rTOM, _aA, _t, _n, _r, _rA, _pR, _o, _v, _uA],
+    [0, 0, () => WorkflowList, 0, 1, () => AssociatedAlarmMap, () => TriggerList, 0, 64 | 0, 0, 0, 0, 0, 4],
+];
+var RegionSwitchPlanConfiguration = [3, n0, _RSPC, 0, [_cAR, _eIx, _a], [0, 0, 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _cl,
+        [_hE]: 404,
+    },
+    [_me],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ResourceWarning = [
+    3,
+    n0,
+    _RW,
+    0,
+    [_wo, _v, _sN, _rAe, _wS, _wUT, _wM],
+    [() => MinimalWorkflow, 0, 0, 0, 0, 4, 0],
+];
+var Route53HealthCheck = [3, n0, _RHC, 0, [_hZI, _rN, _hCI, _reg], [0, 0, 0, 0]];
+var Route53HealthCheckConfiguration = [
+    3,
+    n0,
+    _RHCC,
+    0,
+    [_tM, _cAR, _eIx, _hZI, _rN, _rS],
+    [1, 0, 0, 0, 0, () => Route53ResourceRecordSetList],
+];
+var Route53ResourceRecordSet = [3, n0, _RRRS, 0, [_rSI, _reg], [0, 0]];
+var Service = [3, n0, _S, 0, [_cAR, _eIx, _cA, _sA], [0, 0, 0, 0]];
+var StartPlanExecutionRequest = [
+    3,
+    n0,
+    _SPER,
+    0,
+    [_pA, _tR, _ac, _m, _c, _lV],
+    [0, 0, 0, 0, 0, 0],
+];
+var StartPlanExecutionResponse = [
+    3,
+    n0,
+    _SPERt,
+    0,
+    [_eI, _p, _pV, _aRc, _dR],
+    [0, 0, 0, 0, 0],
+];
+var Step = [
+    3,
+    n0,
+    _St,
+    0,
+    [_n, _d, _eBC, _eBT],
+    [0, 0, () => ExecutionBlockConfiguration, 0],
+];
+var StepState = [3, n0, _SS, 0, [_n, _sta, _sT, _eT, _sM], [0, 0, 4, 4, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_a, _ta], [0, 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var Trigger = [
+    3,
+    n0,
+    _T,
+    0,
+    [_d, _tR, _ac, _co, _mDMBE],
+    [0, 0, 0, () => TriggerConditionList, 1],
+];
+var TriggerCondition = [3, n0, _TC, 0, [_aAN, _con], [0, 0]];
+var UntagResourceRequest = [3, n0, _URR, 0, [_a, _rTK], [0, 64 | 0]];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdatePlanExecutionRequest = [3, n0, _UPER, 0, [_pA, _eI, _ac, _c], [0, 0, 0, 0]];
+var UpdatePlanExecutionResponse = [3, n0, _UPERp, 0, [], []];
+var UpdatePlanExecutionStepRequest = [
+    3,
+    n0,
+    _UPESR,
+    0,
+    [_pA, _eI, _c, _sN, _aTT],
+    [0, 0, 0, 0, 0],
+];
+var UpdatePlanExecutionStepResponse = [3, n0, _UPESRp, 0, [], []];
+var UpdatePlanRequest = [
+    3,
+    n0,
+    _UPR,
+    0,
+    [_a, _d, _w, _eRx, _rTOM, _aA, _t],
+    [0, 0, () => WorkflowList, 0, 1, () => AssociatedAlarmMap, () => TriggerList],
+];
+var UpdatePlanResponse = [3, n0, _UPRp, 0, [_p], [() => Plan]];
+var Workflow = [3, n0, _W, 0, [_st, _wTA, _wTR, _wD], [() => Steps, 0, 0, 0]];
+var ARCRegionSwitchServiceException = [-3, _sm, "ARCRegionSwitchServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(ARCRegionSwitchServiceException, ARCRegionSwitchServiceException$1);
+var AbbreviatedExecutionsList = [1, n0, _AEL, 0, () => AbbreviatedExecution];
+var ArcRoutingControlStates = [1, n0, _ARCSr, 0, () => ArcRoutingControlState];
+var AsgList = [1, n0, _AL, 0, () => Asg];
+var EksClusters = [1, n0, _ECk, 0, () => EksCluster];
+var ExecutionEventList = [1, n0, _EEL, 0, () => ExecutionEvent];
+var KubernetesScalingApps = [1, n0, _KSA, 0, () => KubernetesScalingApplication];
+var LambdaList = [1, n0, _LL, 0, () => Lambdas];
+var PlanList = [1, n0, _PL, 0, () => AbbreviatedPlan];
+var PlanWarnings = [1, n0, _PW, 0, () => ResourceWarning];
+var Route53HealthCheckList = [1, n0, _RHCL, 0, () => Route53HealthCheck];
+var Route53ResourceRecordSetList = [1, n0, _RRRSL, 0, () => Route53ResourceRecordSet];
+var ServiceList = [1, n0, _SL, 0, () => Service];
+var Steps = [1, n0, _Ste, 0, () => Step];
+var StepStates = [1, n0, _SSt, 0, () => StepState];
+var TriggerConditionList = [1, n0, _TCL, 0, () => TriggerCondition];
+var TriggerList = [1, n0, _TL, 0, () => Trigger];
+var WorkflowList = [1, n0, _WL, 0, () => Workflow];
+var AssociatedAlarmMap = [2, n0, _AAM, 0, 0, () => AssociatedAlarm];
+var KubernetesScalingApplication = [2, n0, _KSAu, 0, 0, () => RegionalScalingResource];
+var RegionalScalingResource = [2, n0, _RSR, 0, 0, () => KubernetesScalingResource];
+var RegionAndRoutingControls = [2, n0, _RARC, 0, 0, () => ArcRoutingControlStates];
+var ExecutionBlockConfiguration = [
+    3,
+    n0,
+    _EBC,
+    0,
+    [_cALC, _eACIC, _eAC, _aRCC, _gAC, _pC, _rSPC, _eCIC, _eRSC, _rHCC],
+    [
+        () => CustomActionLambdaConfiguration,
+        () => Ec2AsgCapacityIncreaseConfiguration,
+        () => ExecutionApprovalConfiguration,
+        () => ArcRoutingControlConfiguration,
+        () => GlobalAuroraConfiguration,
+        () => ParallelExecutionBlockConfiguration,
+        () => RegionSwitchPlanConfiguration,
+        () => EcsCapacityIncreaseConfiguration,
+        () => EksResourceScalingConfiguration,
+        () => Route53HealthCheckConfiguration,
+    ],
+];
+var ApprovePlanExecutionStep = [
+    9,
+    n0,
+    _APES,
+    0,
+    () => ApprovePlanExecutionStepRequest,
+    () => ApprovePlanExecutionStepResponse,
+];
+var CancelPlanExecution = [
+    9,
+    n0,
+    _CPE,
+    0,
+    () => CancelPlanExecutionRequest,
+    () => CancelPlanExecutionResponse,
+];
+var CreatePlan = [9, n0, _CP, 0, () => CreatePlanRequest, () => CreatePlanResponse];
+var DeletePlan = [9, n0, _DP, 2, () => DeletePlanRequest, () => DeletePlanResponse];
+var GetPlan = [9, n0, _GP, 0, () => GetPlanRequest, () => GetPlanResponse];
+var GetPlanEvaluationStatus = [
+    9,
+    n0,
+    _GPES,
+    0,
+    () => GetPlanEvaluationStatusRequest,
+    () => GetPlanEvaluationStatusResponse,
+];
+var GetPlanExecution = [
+    9,
+    n0,
+    _GPE,
+    0,
+    () => GetPlanExecutionRequest,
+    () => GetPlanExecutionResponse,
+];
+var GetPlanInRegion = [
+    9,
+    n0,
+    _GPIR,
+    0,
+    () => GetPlanInRegionRequest,
+    () => GetPlanInRegionResponse,
+];
+var ListPlanExecutionEvents = [
+    9,
+    n0,
+    _LPEE,
+    0,
+    () => ListPlanExecutionEventsRequest,
+    () => ListPlanExecutionEventsResponse,
+];
+var ListPlanExecutions = [
+    9,
+    n0,
+    _LPE,
+    0,
+    () => ListPlanExecutionsRequest,
+    () => ListPlanExecutionsResponse,
+];
+var ListPlans = [9, n0, _LP, 0, () => ListPlansRequest, () => ListPlansResponse];
+var ListPlansInRegion = [
+    9,
+    n0,
+    _LPIR,
+    0,
+    () => ListPlansInRegionRequest,
+    () => ListPlansInRegionResponse,
+];
+var ListRoute53HealthChecks = [
+    9,
+    n0,
+    _LRHC,
+    0,
+    () => ListRoute53HealthChecksRequest,
+    () => ListRoute53HealthChecksResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    0,
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var StartPlanExecution = [
+    9,
+    n0,
+    _SPE,
+    0,
+    () => StartPlanExecutionRequest,
+    () => StartPlanExecutionResponse,
+];
+var TagResource = [9, n0, _TR, 0, () => TagResourceRequest, () => TagResourceResponse];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    0,
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdatePlan = [9, n0, _UP, 0, () => UpdatePlanRequest, () => UpdatePlanResponse];
+var UpdatePlanExecution = [
+    9,
+    n0,
+    _UPE,
+    0,
+    () => UpdatePlanExecutionRequest,
+    () => UpdatePlanExecutionResponse,
+];
+var UpdatePlanExecutionStep = [
+    9,
+    n0,
+    _UPES,
+    0,
+    () => UpdatePlanExecutionStepRequest,
+    () => UpdatePlanExecutionStepResponse,
+];
 
 class ApprovePlanExecutionStepCommand 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("ArcRegionSwitch", "ApprovePlanExecutionStep", {})
     .n("ARCRegionSwitchClient", "ApprovePlanExecutionStepCommand")
-    .f(void 0, void 0)
-    .ser(se_ApprovePlanExecutionStepCommand)
-    .de(de_ApprovePlanExecutionStepCommand)
+    .sc(ApprovePlanExecutionStep)
     .build() {
 }
 
@@ -1230,16 +1097,11 @@ class CancelPlanExecutionCommand 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("ArcRegionSwitch", "CancelPlanExecution", {})
     .n("ARCRegionSwitchClient", "CancelPlanExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_CancelPlanExecutionCommand)
-    .de(de_CancelPlanExecutionCommand)
+    .sc(CancelPlanExecution)
     .build() {
 }
 
@@ -1250,16 +1112,11 @@ class CreatePlanCommand extends smithyClient.Command
     UseControlPlaneEndpoint: { type: "staticContextParams", value: true },
 })
     .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("ArcRegionSwitch", "CreatePlan", {})
     .n("ARCRegionSwitchClient", "CreatePlanCommand")
-    .f(void 0, void 0)
-    .ser(se_CreatePlanCommand)
-    .de(de_CreatePlanCommand)
+    .sc(CreatePlan)
     .build() {
 }
 
@@ -1270,16 +1127,11 @@ class DeletePlanCommand extends smithyClient.Command
     UseControlPlaneEndpoint: { type: "staticContextParams", value: true },
 })
     .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("ArcRegionSwitch", "DeletePlan", {})
     .n("ARCRegionSwitchClient", "DeletePlanCommand")
-    .f(void 0, void 0)
-    .ser(se_DeletePlanCommand)
-    .de(de_DeletePlanCommand)
+    .sc(DeletePlan)
     .build() {
 }
 
@@ -1290,16 +1142,11 @@ class GetPlanCommand extends smithyClient.Command
     UseControlPlaneEndpoint: { type: "staticContextParams", value: true },
 })
     .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("ArcRegionSwitch", "GetPlan", {})
     .n("ARCRegionSwitchClient", "GetPlanCommand")
-    .f(void 0, void 0)
-    .ser(se_GetPlanCommand)
-    .de(de_GetPlanCommand)
+    .sc(GetPlan)
     .build() {
 }
 
@@ -1307,16 +1154,11 @@ class GetPlanEvaluationStatusCommand 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("ArcRegionSwitch", "GetPlanEvaluationStatus", {})
     .n("ARCRegionSwitchClient", "GetPlanEvaluationStatusCommand")
-    .f(void 0, void 0)
-    .ser(se_GetPlanEvaluationStatusCommand)
-    .de(de_GetPlanEvaluationStatusCommand)
+    .sc(GetPlanEvaluationStatus)
     .build() {
 }
 
@@ -1324,16 +1166,11 @@ class GetPlanExecutionCommand 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("ArcRegionSwitch", "GetPlanExecution", {})
     .n("ARCRegionSwitchClient", "GetPlanExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_GetPlanExecutionCommand)
-    .de(de_GetPlanExecutionCommand)
+    .sc(GetPlanExecution)
     .build() {
 }
 
@@ -1341,16 +1178,11 @@ class GetPlanInRegionCommand 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("ArcRegionSwitch", "GetPlanInRegion", {})
     .n("ARCRegionSwitchClient", "GetPlanInRegionCommand")
-    .f(void 0, void 0)
-    .ser(se_GetPlanInRegionCommand)
-    .de(de_GetPlanInRegionCommand)
+    .sc(GetPlanInRegion)
     .build() {
 }
 
@@ -1358,16 +1190,11 @@ class ListPlanExecutionEventsCommand 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("ArcRegionSwitch", "ListPlanExecutionEvents", {})
     .n("ARCRegionSwitchClient", "ListPlanExecutionEventsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListPlanExecutionEventsCommand)
-    .de(de_ListPlanExecutionEventsCommand)
+    .sc(ListPlanExecutionEvents)
     .build() {
 }
 
@@ -1375,16 +1202,11 @@ class ListPlanExecutionsCommand 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("ArcRegionSwitch", "ListPlanExecutions", {})
     .n("ARCRegionSwitchClient", "ListPlanExecutionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListPlanExecutionsCommand)
-    .de(de_ListPlanExecutionsCommand)
+    .sc(ListPlanExecutions)
     .build() {
 }
 
@@ -1395,16 +1217,11 @@ class ListPlansCommand extends smithyClient.Command
     UseControlPlaneEndpoint: { type: "staticContextParams", value: true },
 })
     .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("ArcRegionSwitch", "ListPlans", {})
     .n("ARCRegionSwitchClient", "ListPlansCommand")
-    .f(void 0, void 0)
-    .ser(se_ListPlansCommand)
-    .de(de_ListPlansCommand)
+    .sc(ListPlans)
     .build() {
 }
 
@@ -1412,16 +1229,11 @@ class ListPlansInRegionCommand 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("ArcRegionSwitch", "ListPlansInRegion", {})
     .n("ARCRegionSwitchClient", "ListPlansInRegionCommand")
-    .f(void 0, void 0)
-    .ser(se_ListPlansInRegionCommand)
-    .de(de_ListPlansInRegionCommand)
+    .sc(ListPlansInRegion)
     .build() {
 }
 
@@ -1432,16 +1244,11 @@ class ListRoute53HealthChecksCommand extends smithyClient.Command
     UseControlPlaneEndpoint: { type: "staticContextParams", value: true },
 })
     .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("ArcRegionSwitch", "ListRoute53HealthChecks", {})
     .n("ARCRegionSwitchClient", "ListRoute53HealthChecksCommand")
-    .f(void 0, void 0)
-    .ser(se_ListRoute53HealthChecksCommand)
-    .de(de_ListRoute53HealthChecksCommand)
+    .sc(ListRoute53HealthChecks)
     .build() {
 }
 
@@ -1452,16 +1259,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     UseControlPlaneEndpoint: { type: "staticContextParams", value: true },
 })
     .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("ArcRegionSwitch", "ListTagsForResource", {})
     .n("ARCRegionSwitchClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1469,16 +1271,11 @@ class StartPlanExecutionCommand 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("ArcRegionSwitch", "StartPlanExecution", {})
     .n("ARCRegionSwitchClient", "StartPlanExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_StartPlanExecutionCommand)
-    .de(de_StartPlanExecutionCommand)
+    .sc(StartPlanExecution)
     .build() {
 }
 
@@ -1489,16 +1286,11 @@ class TagResourceCommand extends smithyClient.Command
     UseControlPlaneEndpoint: { type: "staticContextParams", value: true },
 })
     .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("ArcRegionSwitch", "TagResource", {})
     .n("ARCRegionSwitchClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1509,16 +1301,11 @@ class UntagResourceCommand extends smithyClient.Command
     UseControlPlaneEndpoint: { type: "staticContextParams", value: true },
 })
     .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("ArcRegionSwitch", "UntagResource", {})
     .n("ARCRegionSwitchClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1529,16 +1316,11 @@ class UpdatePlanCommand extends smithyClient.Command
     UseControlPlaneEndpoint: { type: "staticContextParams", value: true },
 })
     .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("ArcRegionSwitch", "UpdatePlan", {})
     .n("ARCRegionSwitchClient", "UpdatePlanCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdatePlanCommand)
-    .de(de_UpdatePlanCommand)
+    .sc(UpdatePlan)
     .build() {
 }
 
@@ -1546,16 +1328,11 @@ class UpdatePlanExecutionCommand 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("ArcRegionSwitch", "UpdatePlanExecution", {})
     .n("ARCRegionSwitchClient", "UpdatePlanExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdatePlanExecutionCommand)
-    .de(de_UpdatePlanExecutionCommand)
+    .sc(UpdatePlanExecution)
     .build() {
 }
 
@@ -1563,16 +1340,11 @@ class UpdatePlanExecutionStepCommand 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("ArcRegionSwitch", "UpdatePlanExecutionStep", {})
     .n("ARCRegionSwitchClient", "UpdatePlanExecutionStepCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdatePlanExecutionStepCommand)
-    .de(de_UpdatePlanExecutionStepCommand)
+    .sc(UpdatePlanExecutionStep)
     .build() {
 }
 
@@ -1740,8 +1512,8 @@ Object.defineProperty(exports, "__Client", {
 });
 exports.ARCRegionSwitch = ARCRegionSwitch;
 exports.ARCRegionSwitchClient = ARCRegionSwitchClient;
-exports.ARCRegionSwitchServiceException = ARCRegionSwitchServiceException;
-exports.AccessDeniedException = AccessDeniedException;
+exports.ARCRegionSwitchServiceException = ARCRegionSwitchServiceException$1;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AlarmCondition = AlarmCondition;
 exports.AlarmType = AlarmType;
 exports.Approval = Approval;
@@ -1764,9 +1536,9 @@ exports.GetPlanExecutionCommand = GetPlanExecutionCommand;
 exports.GetPlanInRegionCommand = GetPlanInRegionCommand;
 exports.GlobalAuroraDefaultBehavior = GlobalAuroraDefaultBehavior;
 exports.GlobalAuroraUngracefulBehavior = GlobalAuroraUngracefulBehavior;
-exports.IllegalArgumentException = IllegalArgumentException;
-exports.IllegalStateException = IllegalStateException;
-exports.InternalServerException = InternalServerException;
+exports.IllegalArgumentException = IllegalArgumentException$1;
+exports.IllegalStateException = IllegalStateException$1;
+exports.InternalServerException = InternalServerException$1;
 exports.LambdaUngracefulBehavior = LambdaUngracefulBehavior;
 exports.ListPlanExecutionEventsCommand = ListPlanExecutionEventsCommand;
 exports.ListPlanExecutionsCommand = ListPlanExecutionsCommand;
@@ -1776,7 +1548,7 @@ exports.ListRoute53HealthChecksCommand = ListRoute53HealthChecksCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.RecoveryApproach = RecoveryApproach;
 exports.RegionToRunIn = RegionToRunIn;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ResourceWarningStatus = ResourceWarningStatus;
 exports.RoutingControlStateChange = RoutingControlStateChange;
 exports.StartPlanExecutionCommand = StartPlanExecutionCommand;