@aws-sdk/client-arc-region-switch 3.893.0 → 3.894.0

package/dist-cjs/index.js

@@ -1,12 +1,1932 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ARCRegionSwitchServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ARCRegionSwitchClient"), exports);
-tslib_1.__exportStar(require("./ARCRegionSwitch"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-var ARCRegionSwitchServiceException_1 = require("./models/ARCRegionSwitchServiceException");
-Object.defineProperty(exports, "ARCRegionSwitchServiceException", { enumerable: true, get: function () { return ARCRegionSwitchServiceException_1.ARCRegionSwitchServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ARCRegionSwitch: () => ARCRegionSwitch,
+  ARCRegionSwitchClient: () => ARCRegionSwitchClient,
+  ARCRegionSwitchServiceException: () => ARCRegionSwitchServiceException,
+  AccessDeniedException: () => AccessDeniedException,
+  AlarmCondition: () => AlarmCondition,
+  AlarmType: () => AlarmType,
+  Approval: () => Approval,
+  ApprovePlanExecutionStepCommand: () => ApprovePlanExecutionStepCommand,
+  CancelPlanExecutionCommand: () => CancelPlanExecutionCommand,
+  CreatePlanCommand: () => CreatePlanCommand,
+  DeletePlanCommand: () => DeletePlanCommand,
+  Ec2AsgCapacityMonitoringApproach: () => Ec2AsgCapacityMonitoringApproach,
+  EcsCapacityMonitoringApproach: () => EcsCapacityMonitoringApproach,
+  EksCapacityMonitoringApproach: () => EksCapacityMonitoringApproach,
+  EvaluationStatus: () => EvaluationStatus,
+  ExecutionAction: () => ExecutionAction,
+  ExecutionBlockConfiguration: () => ExecutionBlockConfiguration,
+  ExecutionBlockType: () => ExecutionBlockType,
+  ExecutionEventType: () => ExecutionEventType,
+  ExecutionMode: () => ExecutionMode,
+  ExecutionState: () => ExecutionState,
+  GetPlanCommand: () => GetPlanCommand,
+  GetPlanEvaluationStatusCommand: () => GetPlanEvaluationStatusCommand,
+  GetPlanExecutionCommand: () => GetPlanExecutionCommand,
+  GetPlanInRegionCommand: () => GetPlanInRegionCommand,
+  GlobalAuroraDefaultBehavior: () => GlobalAuroraDefaultBehavior,
+  GlobalAuroraUngracefulBehavior: () => GlobalAuroraUngracefulBehavior,
+  IllegalArgumentException: () => IllegalArgumentException,
+  IllegalStateException: () => IllegalStateException,
+  InternalServerException: () => InternalServerException,
+  LambdaUngracefulBehavior: () => LambdaUngracefulBehavior,
+  ListPlanExecutionEventsCommand: () => ListPlanExecutionEventsCommand,
+  ListPlanExecutionsCommand: () => ListPlanExecutionsCommand,
+  ListPlansCommand: () => ListPlansCommand,
+  ListPlansInRegionCommand: () => ListPlansInRegionCommand,
+  ListRoute53HealthChecksCommand: () => ListRoute53HealthChecksCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  RecoveryApproach: () => RecoveryApproach,
+  RegionToRunIn: () => RegionToRunIn,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResourceWarningStatus: () => ResourceWarningStatus,
+  RoutingControlStateChange: () => RoutingControlStateChange,
+  StartPlanExecutionCommand: () => StartPlanExecutionCommand,
+  StepStatus: () => StepStatus,
+  TagResourceCommand: () => TagResourceCommand,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdatePlanCommand: () => UpdatePlanCommand,
+  UpdatePlanExecutionAction: () => UpdatePlanExecutionAction,
+  UpdatePlanExecutionCommand: () => UpdatePlanExecutionCommand,
+  UpdatePlanExecutionStepAction: () => UpdatePlanExecutionStepAction,
+  UpdatePlanExecutionStepCommand: () => UpdatePlanExecutionStepCommand,
+  WorkflowTargetAction: () => WorkflowTargetAction,
+  __Client: () => import_smithy_client.Client,
+  paginateGetPlanEvaluationStatus: () => paginateGetPlanEvaluationStatus,
+  paginateGetPlanExecution: () => paginateGetPlanExecution,
+  paginateListPlanExecutionEvents: () => paginateListPlanExecutionEvents,
+  paginateListPlanExecutions: () => paginateListPlanExecutions,
+  paginateListPlans: () => paginateListPlans,
+  paginateListPlansInRegion: () => paginateListPlansInRegion,
+  paginateListRoute53HealthChecks: () => paginateListRoute53HealthChecks,
+  waitForPlanEvaluationStatusPassed: () => waitForPlanEvaluationStatusPassed,
+  waitForPlanExecutionCompleted: () => waitForPlanExecutionCompleted,
+  waitUntilPlanEvaluationStatusPassed: () => waitUntilPlanEvaluationStatusPassed,
+  waitUntilPlanExecutionCompleted: () => waitUntilPlanExecutionCompleted
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ARCRegionSwitchClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_core = require("@smithy/core");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return Object.assign(options, {
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "arc-region-switch"
+  });
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" }
+};
+
+// src/ARCRegionSwitchClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+
+// src/auth/httpAuthExtensionConfiguration.ts
+var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+}, "getHttpAuthExtensionConfiguration");
+var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+}, "resolveHttpAuthRuntimeConfig");
+
+// src/runtimeExtensions.ts
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = Object.assign(
+    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
+    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
+    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
+    getHttpAuthExtensionConfiguration(runtimeConfig)
+  );
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return Object.assign(
+    runtimeConfig,
+    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
+    resolveHttpAuthRuntimeConfig(extensionConfiguration)
+  );
+}, "resolveRuntimeExtensions");
+
+// src/ARCRegionSwitchClient.ts
+var ARCRegionSwitchClient = class extends import_smithy_client.Client {
+  static {
+    __name(this, "ARCRegionSwitchClient");
+  }
+  /**
+   * The resolved configuration of ARCRegionSwitchClient class. This is resolved and normalized from the {@link ARCRegionSwitchClientConfig | constructor configuration interface}.
+   */
+  config;
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    super(_config_0);
+    this.initConfig = _config_0;
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
+    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
+    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
+    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use(
+      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
+        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultARCRegionSwitchHttpAuthSchemeParametersProvider,
+        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
+          "aws.auth#sigv4": config.credentials
+        }), "identityProviderConfigProvider")
+      })
+    );
+    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+
+// src/ARCRegionSwitch.ts
+
+
+// src/commands/ApprovePlanExecutionStepCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+
+// src/protocols/Aws_json1_0.ts
+var import_core2 = require("@aws-sdk/core");
+
+
+
+// src/models/ARCRegionSwitchServiceException.ts
+
+var ARCRegionSwitchServiceException = class _ARCRegionSwitchServiceException extends import_smithy_client.ServiceException {
+  static {
+    __name(this, "ARCRegionSwitchServiceException");
+  }
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ARCRegionSwitchServiceException.prototype);
+  }
+};
+
+// src/models/models_0.ts
+var ExecutionAction = {
+  ACTIVATE: "activate",
+  DEACTIVATE: "deactivate"
+};
+var ExecutionState = {
+  CANCELLED: "canceled",
+  COMPLETED: "completed",
+  COMPLETED_MONITORING_APPLICATION_HEALTH: "completedMonitoringApplicationHealth",
+  COMPLETED_WITH_EXCEPTIONS: "completedWithExceptions",
+  FAILED: "failed",
+  IN_PROGRESS: "inProgress",
+  PAUSED_BY_FAILED_STEP: "pausedByFailedStep",
+  PAUSED_BY_OPERATOR: "pausedByOperator",
+  PENDING: "pending",
+  PENDING_MANUAL_APPROVAL: "pendingManualApproval",
+  PLAN_EXECUTION_TIMED_OUT: "planExecutionTimedOut"
+};
+var ExecutionMode = {
+  GRACEFUL: "graceful",
+  UNGRACEFUL: "ungraceful"
+};
+var RecoveryApproach = {
+  ACTIVE_ACTIVE: "activeActive",
+  ACTIVE_PASSIVE: "activePassive"
+};
+var AccessDeniedException = class _AccessDeniedException extends ARCRegionSwitchServiceException {
+  static {
+    __name(this, "AccessDeniedException");
+  }
+  name = "AccessDeniedException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+var AlarmCondition = {
+  GREEN: "green",
+  RED: "red"
+};
+var AlarmType = {
+  APPLICATION_HEALTH: "applicationHealth",
+  TRIGGER: "trigger"
+};
+var Approval = {
+  APPROVE: "approve",
+  DECLINE: "decline"
+};
+var ResourceNotFoundException = class _ResourceNotFoundException extends ARCRegionSwitchServiceException {
+  static {
+    __name(this, "ResourceNotFoundException");
+  }
+  name = "ResourceNotFoundException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+var EvaluationStatus = {
+  ACTION_REQUIRED: "actionRequired",
+  PASSED: "passed",
+  PENDING_EVALUATION: "pendingEvaluation",
+  UNKNOWN: "unknown"
+};
+var ResourceWarningStatus = {
+  ACTIVE: "active",
+  RESOLVED: "resolved"
+};
+var WorkflowTargetAction = {
+  ACTIVATE: "activate",
+  DEACTIVATE: "deactivate"
+};
+var RoutingControlStateChange = {
+  OFF: "Off",
+  ON: "On"
+};
+var RegionToRunIn = {
+  ACTIVATING_REGION: "activatingRegion",
+  DEACTIVATING_REGION: "deactivatingRegion"
+};
+var LambdaUngracefulBehavior = {
+  SKIP: "skip"
+};
+var Ec2AsgCapacityMonitoringApproach = {
+  AUTOSCALING_MAX_IN_LAST_24_HOURS: "autoscalingMaxInLast24Hours",
+  SAMPLED_MAX_IN_LAST_24_HOURS: "sampledMaxInLast24Hours"
+};
+var EcsCapacityMonitoringApproach = {
+  CONTAINER_INSIGHTS_MAX_IN_LAST_24_HOURS: "containerInsightsMaxInLast24Hours",
+  SAMPLED_MAX_IN_LAST_24_HOURS: "sampledMaxInLast24Hours"
+};
+var EksCapacityMonitoringApproach = {
+  SAMPLED_MAX_IN_LAST_24_HOURS: "sampledMaxInLast24Hours"
+};
+var GlobalAuroraDefaultBehavior = {
+  FAILOVER: "failover",
+  SWITCHOVER_ONLY: "switchoverOnly"
+};
+var GlobalAuroraUngracefulBehavior = {
+  FAILOVER: "failover"
+};
+var ExecutionBlockType = {
+  AURORA: "AuroraGlobalDatabase",
+  CUSTOM_ACTION_LAMBDA: "CustomActionLambda",
+  EC2_ASG: "EC2AutoScaling",
+  ECS: "ECSServiceScaling",
+  EKS_RESOURCE_SCALING: "EKSResourceScaling",
+  EXECUTION_APPROVAL: "ManualApproval",
+  PARALLEL: "Parallel",
+  REGION_SWITCH: "ARCRegionSwitchPlan",
+  ROUTE53_HEALTH_CHECK: "Route53HealthCheck",
+  ROUTING_CONTROL: "ARCRoutingControl"
+};
+var StepStatus = {
+  CANCELLED: "canceled",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  NOT_STARTED: "notStarted",
+  PENDING_APPROVAL: "pendingApproval",
+  RUNNING: "running",
+  SKIPPED: "skipped"
+};
+var ExecutionEventType = {
+  EXECUTION_BEHAVIOR_CHANGED_TO_GRACEFUL: "executionBehaviorChangedToGraceful",
+  EXECUTION_BEHAVIOR_CHANGED_TO_UNGRACEFUL: "executionBehaviorChangedToUngraceful",
+  EXECUTION_CANCELED: "executionCanceled",
+  EXECUTION_CANCELING: "executionCanceling",
+  EXECUTION_FAILED: "executionFailed",
+  EXECUTION_PAUSED: "executionPaused",
+  EXECUTION_PAUSING: "executionPausing",
+  EXECUTION_PENDING: "executionPending",
+  EXECUTION_PENDING_APPROVAL: "executionPendingApproval",
+  EXECUTION_PENDING_CHILD_PLAN_MANUAL_APPROVAL: "executionPendingChildPlanManualApproval",
+  EXECUTION_STARTED: "executionStarted",
+  EXECUTION_SUCCEEDED: "executionSucceeded",
+  EXECUTION_SUCCESS_MONITORING_APPLICATION_HEALTH: "executionSuccessMonitoringApplicationHealth",
+  STEP_CANCELED: "stepCanceled",
+  STEP_EXECUTION_BEHAVIOR_CHANGED_TO_UNGRACEFUL: "stepExecutionBehaviorChangedToUngraceful",
+  STEP_FAILED: "stepFailed",
+  STEP_PAUSED_BY_ERROR: "stepPausedByError",
+  STEP_PAUSED_BY_OPERATOR: "stepPausedByOperator",
+  STEP_PENDING_APPLICATION_HEALTH_MONITOR: "stepPendingApplicationHealthMonitor",
+  STEP_PENDING_APPROVAL: "stepPendingApproval",
+  STEP_SKIPPED: "stepSkipped",
+  STEP_STARTED: "stepStarted",
+  STEP_SUCCEEDED: "stepSucceeded",
+  STEP_UPDATE: "stepUpdate",
+  UNKNOWN: "unknown"
+};
+var InternalServerException = class _InternalServerException extends ARCRegionSwitchServiceException {
+  static {
+    __name(this, "InternalServerException");
+  }
+  name = "InternalServerException";
+  $fault = "server";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+  }
+};
+var IllegalStateException = class _IllegalStateException extends ARCRegionSwitchServiceException {
+  static {
+    __name(this, "IllegalStateException");
+  }
+  name = "IllegalStateException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "IllegalStateException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _IllegalStateException.prototype);
+  }
+};
+var IllegalArgumentException = class _IllegalArgumentException extends ARCRegionSwitchServiceException {
+  static {
+    __name(this, "IllegalArgumentException");
+  }
+  name = "IllegalArgumentException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "IllegalArgumentException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _IllegalArgumentException.prototype);
+  }
+};
+var UpdatePlanExecutionAction = {
+  PAUSE: "pause",
+  RESUME: "resume",
+  SWITCH_TO_GRACEFUL: "switchToGraceful",
+  SWITCH_TO_UNGRACEFUL: "switchToUngraceful"
+};
+var UpdatePlanExecutionStepAction = {
+  SKIP: "skip",
+  SWITCH_TO_UNGRACEFUL: "switchToUngraceful"
+};
+var ExecutionBlockConfiguration;
+((ExecutionBlockConfiguration2) => {
+  ExecutionBlockConfiguration2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.customActionLambdaConfig !== void 0)
+      return visitor.customActionLambdaConfig(value.customActionLambdaConfig);
+    if (value.ec2AsgCapacityIncreaseConfig !== void 0)
+      return visitor.ec2AsgCapacityIncreaseConfig(value.ec2AsgCapacityIncreaseConfig);
+    if (value.executionApprovalConfig !== void 0)
+      return visitor.executionApprovalConfig(value.executionApprovalConfig);
+    if (value.arcRoutingControlConfig !== void 0)
+      return visitor.arcRoutingControlConfig(value.arcRoutingControlConfig);
+    if (value.globalAuroraConfig !== void 0) return visitor.globalAuroraConfig(value.globalAuroraConfig);
+    if (value.parallelConfig !== void 0) return visitor.parallelConfig(value.parallelConfig);
+    if (value.regionSwitchPlanConfig !== void 0) return visitor.regionSwitchPlanConfig(value.regionSwitchPlanConfig);
+    if (value.ecsCapacityIncreaseConfig !== void 0)
+      return visitor.ecsCapacityIncreaseConfig(value.ecsCapacityIncreaseConfig);
+    if (value.eksResourceScalingConfig !== void 0)
+      return visitor.eksResourceScalingConfig(value.eksResourceScalingConfig);
+    if (value.route53HealthCheckConfig !== void 0)
+      return visitor.route53HealthCheckConfig(value.route53HealthCheckConfig);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ExecutionBlockConfiguration || (ExecutionBlockConfiguration = {}));
+
+// src/protocols/Aws_json1_0.ts
+var se_ApprovePlanExecutionStepCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ApprovePlanExecutionStep");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ApprovePlanExecutionStepCommand");
+var se_CancelPlanExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CancelPlanExecution");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CancelPlanExecutionCommand");
+var se_CreatePlanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreatePlan");
+  let body;
+  body = JSON.stringify(se_CreatePlanRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreatePlanCommand");
+var se_DeletePlanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeletePlan");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeletePlanCommand");
+var se_GetPlanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetPlan");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetPlanCommand");
+var se_GetPlanEvaluationStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetPlanEvaluationStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetPlanEvaluationStatusCommand");
+var se_GetPlanExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetPlanExecution");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetPlanExecutionCommand");
+var se_GetPlanInRegionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetPlanInRegion");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetPlanInRegionCommand");
+var se_ListPlanExecutionEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListPlanExecutionEvents");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListPlanExecutionEventsCommand");
+var se_ListPlanExecutionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListPlanExecutions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListPlanExecutionsCommand");
+var se_ListPlansCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListPlans");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListPlansCommand");
+var se_ListPlansInRegionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListPlansInRegion");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListPlansInRegionCommand");
+var se_ListRoute53HealthChecksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListRoute53HealthChecks");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListRoute53HealthChecksCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTagsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsForResourceCommand");
+var se_StartPlanExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartPlanExecution");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartPlanExecutionCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var se_UpdatePlanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdatePlan");
+  let body;
+  body = JSON.stringify(se_UpdatePlanRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdatePlanCommand");
+var se_UpdatePlanExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdatePlanExecution");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdatePlanExecutionCommand");
+var se_UpdatePlanExecutionStepCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdatePlanExecutionStep");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdatePlanExecutionStepCommand");
+var de_ApprovePlanExecutionStepCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ApprovePlanExecutionStepCommand");
+var de_CancelPlanExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CancelPlanExecutionCommand");
+var de_CreatePlanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_CreatePlanResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreatePlanCommand");
+var de_DeletePlanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeletePlanCommand");
+var de_GetPlanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_GetPlanResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetPlanCommand");
+var de_GetPlanEvaluationStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_GetPlanEvaluationStatusResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetPlanEvaluationStatusCommand");
+var de_GetPlanExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_GetPlanExecutionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetPlanExecutionCommand");
+var de_GetPlanInRegionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_GetPlanInRegionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetPlanInRegionCommand");
+var de_ListPlanExecutionEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_ListPlanExecutionEventsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListPlanExecutionEventsCommand");
+var de_ListPlanExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_ListPlanExecutionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListPlanExecutionsCommand");
+var de_ListPlansCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_ListPlansResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListPlansCommand");
+var de_ListPlansInRegionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_ListPlansInRegionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListPlansInRegionCommand");
+var de_ListRoute53HealthChecksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListRoute53HealthChecksCommand");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_StartPlanExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartPlanExecutionCommand");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UpdatePlanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = de_UpdatePlanResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdatePlanCommand");
+var de_UpdatePlanExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdatePlanExecutionCommand");
+var de_UpdatePlanExecutionStepCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await (0, import_core2.parseJsonBody)(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdatePlanExecutionStepCommand");
+var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
+  };
+  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.arcregionswitch#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.arcregionswitch#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "IllegalStateException":
+    case "com.amazonaws.arcregionswitch#IllegalStateException":
+      throw await de_IllegalStateExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.arcregionswitch#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "IllegalArgumentException":
+    case "com.amazonaws.arcregionswitch#IllegalArgumentException":
+      throw await de_IllegalArgumentExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CommandError");
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AccessDeniedExceptionRes");
+var de_IllegalArgumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new IllegalArgumentException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_IllegalArgumentExceptionRes");
+var de_IllegalStateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new IllegalStateException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_IllegalStateExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalServerExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var se_CreatePlanRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    associatedAlarms: import_smithy_client._json,
+    description: [],
+    executionRole: [],
+    name: [],
+    primaryRegion: [],
+    recoveryApproach: [],
+    recoveryTimeObjectiveMinutes: [],
+    regions: import_smithy_client._json,
+    tags: import_smithy_client._json,
+    triggers: import_smithy_client._json,
+    workflows: /* @__PURE__ */ __name((_) => se_WorkflowList(_, context), "workflows")
+  });
+}, "se_CreatePlanRequest");
+var se_CustomActionLambdaConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    lambdas: import_smithy_client._json,
+    regionToRun: [],
+    retryIntervalMinutes: import_smithy_client.serializeFloat,
+    timeoutMinutes: [],
+    ungraceful: import_smithy_client._json
+  });
+}, "se_CustomActionLambdaConfiguration");
+var se_ExecutionBlockConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return ExecutionBlockConfiguration.visit(input, {
+    arcRoutingControlConfig: /* @__PURE__ */ __name((value) => ({ arcRoutingControlConfig: (0, import_smithy_client._json)(value) }), "arcRoutingControlConfig"),
+    customActionLambdaConfig: /* @__PURE__ */ __name((value) => ({
+      customActionLambdaConfig: se_CustomActionLambdaConfiguration(value, context)
+    }), "customActionLambdaConfig"),
+    ec2AsgCapacityIncreaseConfig: /* @__PURE__ */ __name((value) => ({ ec2AsgCapacityIncreaseConfig: (0, import_smithy_client._json)(value) }), "ec2AsgCapacityIncreaseConfig"),
+    ecsCapacityIncreaseConfig: /* @__PURE__ */ __name((value) => ({ ecsCapacityIncreaseConfig: (0, import_smithy_client._json)(value) }), "ecsCapacityIncreaseConfig"),
+    eksResourceScalingConfig: /* @__PURE__ */ __name((value) => ({ eksResourceScalingConfig: (0, import_smithy_client._json)(value) }), "eksResourceScalingConfig"),
+    executionApprovalConfig: /* @__PURE__ */ __name((value) => ({ executionApprovalConfig: (0, import_smithy_client._json)(value) }), "executionApprovalConfig"),
+    globalAuroraConfig: /* @__PURE__ */ __name((value) => ({ globalAuroraConfig: (0, import_smithy_client._json)(value) }), "globalAuroraConfig"),
+    parallelConfig: /* @__PURE__ */ __name((value) => ({ parallelConfig: se_ParallelExecutionBlockConfiguration(value, context) }), "parallelConfig"),
+    regionSwitchPlanConfig: /* @__PURE__ */ __name((value) => ({ regionSwitchPlanConfig: (0, import_smithy_client._json)(value) }), "regionSwitchPlanConfig"),
+    route53HealthCheckConfig: /* @__PURE__ */ __name((value) => ({ route53HealthCheckConfig: (0, import_smithy_client._json)(value) }), "route53HealthCheckConfig"),
+    _: /* @__PURE__ */ __name((name, value) => ({ [name]: value }), "_")
+  });
+}, "se_ExecutionBlockConfiguration");
+var se_ParallelExecutionBlockConfiguration = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    steps: /* @__PURE__ */ __name((_) => se_Steps(_, context), "steps")
+  });
+}, "se_ParallelExecutionBlockConfiguration");
+var se_Step = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    description: [],
+    executionBlockConfiguration: /* @__PURE__ */ __name((_) => se_ExecutionBlockConfiguration(_, context), "executionBlockConfiguration"),
+    executionBlockType: [],
+    name: []
+  });
+}, "se_Step");
+var se_Steps = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Step(entry, context);
+  });
+}, "se_Steps");
+var se_UpdatePlanRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    arn: [],
+    associatedAlarms: import_smithy_client._json,
+    description: [],
+    executionRole: [],
+    recoveryTimeObjectiveMinutes: [],
+    triggers: import_smithy_client._json,
+    workflows: /* @__PURE__ */ __name((_) => se_WorkflowList(_, context), "workflows")
+  });
+}, "se_UpdatePlanRequest");
+var se_Workflow = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    steps: /* @__PURE__ */ __name((_) => se_Steps(_, context), "steps"),
+    workflowDescription: [],
+    workflowTargetAction: [],
+    workflowTargetRegion: []
+  });
+}, "se_Workflow");
+var se_WorkflowList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Workflow(entry, context);
+  });
+}, "se_WorkflowList");
+var de_AbbreviatedExecution = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    actualRecoveryTime: import_smithy_client.expectString,
+    comment: import_smithy_client.expectString,
+    endTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "endTime"),
+    executionAction: import_smithy_client.expectString,
+    executionId: import_smithy_client.expectString,
+    executionRegion: import_smithy_client.expectString,
+    executionState: import_smithy_client.expectString,
+    mode: import_smithy_client.expectString,
+    planArn: import_smithy_client.expectString,
+    startTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "startTime"),
+    updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt"),
+    version: import_smithy_client.expectString
+  });
+}, "de_AbbreviatedExecution");
+var de_AbbreviatedExecutionsList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AbbreviatedExecution(entry, context);
+  });
+  return retVal;
+}, "de_AbbreviatedExecutionsList");
+var de_AbbreviatedPlan = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    activePlanExecution: import_smithy_client.expectString,
+    arn: import_smithy_client.expectString,
+    description: import_smithy_client.expectString,
+    executionRole: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    owner: import_smithy_client.expectString,
+    primaryRegion: import_smithy_client.expectString,
+    recoveryApproach: import_smithy_client.expectString,
+    recoveryTimeObjectiveMinutes: import_smithy_client.expectInt32,
+    regions: import_smithy_client._json,
+    updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt"),
+    version: import_smithy_client.expectString
+  });
+}, "de_AbbreviatedPlan");
+var de_CreatePlanResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    plan: /* @__PURE__ */ __name((_) => de_Plan(_, context), "plan")
+  });
+}, "de_CreatePlanResponse");
+var de_CustomActionLambdaConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    lambdas: import_smithy_client._json,
+    regionToRun: import_smithy_client.expectString,
+    retryIntervalMinutes: import_smithy_client.limitedParseFloat32,
+    timeoutMinutes: import_smithy_client.expectInt32,
+    ungraceful: import_smithy_client._json
+  });
+}, "de_CustomActionLambdaConfiguration");
+var de_ExecutionBlockConfiguration = /* @__PURE__ */ __name((output, context) => {
+  if (output.arcRoutingControlConfig != null) {
+    return {
+      arcRoutingControlConfig: (0, import_smithy_client._json)(output.arcRoutingControlConfig)
+    };
+  }
+  if (output.customActionLambdaConfig != null) {
+    return {
+      customActionLambdaConfig: de_CustomActionLambdaConfiguration(output.customActionLambdaConfig, context)
+    };
+  }
+  if (output.ec2AsgCapacityIncreaseConfig != null) {
+    return {
+      ec2AsgCapacityIncreaseConfig: (0, import_smithy_client._json)(output.ec2AsgCapacityIncreaseConfig)
+    };
+  }
+  if (output.ecsCapacityIncreaseConfig != null) {
+    return {
+      ecsCapacityIncreaseConfig: (0, import_smithy_client._json)(output.ecsCapacityIncreaseConfig)
+    };
+  }
+  if (output.eksResourceScalingConfig != null) {
+    return {
+      eksResourceScalingConfig: (0, import_smithy_client._json)(output.eksResourceScalingConfig)
+    };
+  }
+  if (output.executionApprovalConfig != null) {
+    return {
+      executionApprovalConfig: (0, import_smithy_client._json)(output.executionApprovalConfig)
+    };
+  }
+  if (output.globalAuroraConfig != null) {
+    return {
+      globalAuroraConfig: (0, import_smithy_client._json)(output.globalAuroraConfig)
+    };
+  }
+  if (output.parallelConfig != null) {
+    return {
+      parallelConfig: de_ParallelExecutionBlockConfiguration(output.parallelConfig, context)
+    };
+  }
+  if (output.regionSwitchPlanConfig != null) {
+    return {
+      regionSwitchPlanConfig: (0, import_smithy_client._json)(output.regionSwitchPlanConfig)
+    };
+  }
+  if (output.route53HealthCheckConfig != null) {
+    return {
+      route53HealthCheckConfig: (0, import_smithy_client._json)(output.route53HealthCheckConfig)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ExecutionBlockConfiguration");
+var de_ExecutionEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    description: import_smithy_client.expectString,
+    error: import_smithy_client.expectString,
+    eventId: import_smithy_client.expectString,
+    executionBlockType: import_smithy_client.expectString,
+    previousEventId: import_smithy_client.expectString,
+    resources: import_smithy_client._json,
+    stepName: import_smithy_client.expectString,
+    timestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "timestamp"),
+    type: import_smithy_client.expectString
+  });
+}, "de_ExecutionEvent");
+var de_ExecutionEventList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ExecutionEvent(entry, context);
+  });
+  return retVal;
+}, "de_ExecutionEventList");
+var de_GetPlanEvaluationStatusResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    evaluationState: import_smithy_client.expectString,
+    lastEvaluatedVersion: import_smithy_client.expectString,
+    lastEvaluationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "lastEvaluationTime"),
+    nextToken: import_smithy_client.expectString,
+    planArn: import_smithy_client.expectString,
+    region: import_smithy_client.expectString,
+    warnings: /* @__PURE__ */ __name((_) => de_PlanWarnings(_, context), "warnings")
+  });
+}, "de_GetPlanEvaluationStatusResponse");
+var de_GetPlanExecutionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    actualRecoveryTime: import_smithy_client.expectString,
+    comment: import_smithy_client.expectString,
+    endTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "endTime"),
+    executionAction: import_smithy_client.expectString,
+    executionId: import_smithy_client.expectString,
+    executionRegion: import_smithy_client.expectString,
+    executionState: import_smithy_client.expectString,
+    mode: import_smithy_client.expectString,
+    nextToken: import_smithy_client.expectString,
+    plan: /* @__PURE__ */ __name((_) => de_Plan(_, context), "plan"),
+    planArn: import_smithy_client.expectString,
+    startTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "startTime"),
+    stepStates: /* @__PURE__ */ __name((_) => de_StepStates(_, context), "stepStates"),
+    updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt"),
+    version: import_smithy_client.expectString
+  });
+}, "de_GetPlanExecutionResponse");
+var de_GetPlanInRegionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    plan: /* @__PURE__ */ __name((_) => de_Plan(_, context), "plan")
+  });
+}, "de_GetPlanInRegionResponse");
+var de_GetPlanResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    plan: /* @__PURE__ */ __name((_) => de_Plan(_, context), "plan")
+  });
+}, "de_GetPlanResponse");
+var de_ListPlanExecutionEventsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    items: /* @__PURE__ */ __name((_) => de_ExecutionEventList(_, context), "items"),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_ListPlanExecutionEventsResponse");
+var de_ListPlanExecutionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    items: /* @__PURE__ */ __name((_) => de_AbbreviatedExecutionsList(_, context), "items"),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_ListPlanExecutionsResponse");
+var de_ListPlansInRegionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    plans: /* @__PURE__ */ __name((_) => de_PlanList(_, context), "plans")
+  });
+}, "de_ListPlansInRegionResponse");
+var de_ListPlansResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    plans: /* @__PURE__ */ __name((_) => de_PlanList(_, context), "plans")
+  });
+}, "de_ListPlansResponse");
+var de_ParallelExecutionBlockConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    steps: /* @__PURE__ */ __name((_) => de_Steps(_, context), "steps")
+  });
+}, "de_ParallelExecutionBlockConfiguration");
+var de_Plan = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    associatedAlarms: import_smithy_client._json,
+    description: import_smithy_client.expectString,
+    executionRole: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    owner: import_smithy_client.expectString,
+    primaryRegion: import_smithy_client.expectString,
+    recoveryApproach: import_smithy_client.expectString,
+    recoveryTimeObjectiveMinutes: import_smithy_client.expectInt32,
+    regions: import_smithy_client._json,
+    triggers: import_smithy_client._json,
+    updatedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "updatedAt"),
+    version: import_smithy_client.expectString,
+    workflows: /* @__PURE__ */ __name((_) => de_WorkflowList(_, context), "workflows")
+  });
+}, "de_Plan");
+var de_PlanList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AbbreviatedPlan(entry, context);
+  });
+  return retVal;
+}, "de_PlanList");
+var de_PlanWarnings = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ResourceWarning(entry, context);
+  });
+  return retVal;
+}, "de_PlanWarnings");
+var de_ResourceWarning = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    resourceArn: import_smithy_client.expectString,
+    stepName: import_smithy_client.expectString,
+    version: import_smithy_client.expectString,
+    warningMessage: import_smithy_client.expectString,
+    warningStatus: import_smithy_client.expectString,
+    warningUpdatedTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "warningUpdatedTime"),
+    workflow: import_smithy_client._json
+  });
+}, "de_ResourceWarning");
+var de_Step = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    description: import_smithy_client.expectString,
+    executionBlockConfiguration: /* @__PURE__ */ __name((_) => de_ExecutionBlockConfiguration((0, import_core2.awsExpectUnion)(_), context), "executionBlockConfiguration"),
+    executionBlockType: import_smithy_client.expectString,
+    name: import_smithy_client.expectString
+  });
+}, "de_Step");
+var de_Steps = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Step(entry, context);
+  });
+  return retVal;
+}, "de_Steps");
+var de_StepState = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    endTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "endTime"),
+    name: import_smithy_client.expectString,
+    startTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "startTime"),
+    status: import_smithy_client.expectString,
+    stepMode: import_smithy_client.expectString
+  });
+}, "de_StepState");
+var de_StepStates = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_StepState(entry, context);
+  });
+  return retVal;
+}, "de_StepStates");
+var de_UpdatePlanResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    plan: /* @__PURE__ */ __name((_) => de_Plan(_, context), "plan")
+  });
+}, "de_UpdatePlanResponse");
+var de_Workflow = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    steps: /* @__PURE__ */ __name((_) => de_Steps(_, context), "steps"),
+    workflowDescription: import_smithy_client.expectString,
+    workflowTargetAction: import_smithy_client.expectString,
+    workflowTargetRegion: import_smithy_client.expectString
+  });
+}, "de_Workflow");
+var de_WorkflowList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Workflow(entry, context);
+  });
+  return retVal;
+}, "de_WorkflowList");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(ARCRegionSwitchServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.0",
+    "x-amz-target": `ArcRegionSwitch.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+
+// src/commands/ApprovePlanExecutionStepCommand.ts
+var ApprovePlanExecutionStepCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "ApprovePlanExecutionStep", {}).n("ARCRegionSwitchClient", "ApprovePlanExecutionStepCommand").f(void 0, void 0).ser(se_ApprovePlanExecutionStepCommand).de(de_ApprovePlanExecutionStepCommand).build() {
+  static {
+    __name(this, "ApprovePlanExecutionStepCommand");
+  }
+};
+
+// src/commands/CancelPlanExecutionCommand.ts
+
+
+
+var CancelPlanExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "CancelPlanExecution", {}).n("ARCRegionSwitchClient", "CancelPlanExecutionCommand").f(void 0, void 0).ser(se_CancelPlanExecutionCommand).de(de_CancelPlanExecutionCommand).build() {
+  static {
+    __name(this, "CancelPlanExecutionCommand");
+  }
+};
+
+// src/commands/CreatePlanCommand.ts
+
+
+
+var CreatePlanCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  UseControlPlaneEndpoint: { type: "staticContextParams", value: true }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "CreatePlan", {}).n("ARCRegionSwitchClient", "CreatePlanCommand").f(void 0, void 0).ser(se_CreatePlanCommand).de(de_CreatePlanCommand).build() {
+  static {
+    __name(this, "CreatePlanCommand");
+  }
+};
+
+// src/commands/DeletePlanCommand.ts
+
+
+
+var DeletePlanCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  UseControlPlaneEndpoint: { type: "staticContextParams", value: true }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "DeletePlan", {}).n("ARCRegionSwitchClient", "DeletePlanCommand").f(void 0, void 0).ser(se_DeletePlanCommand).de(de_DeletePlanCommand).build() {
+  static {
+    __name(this, "DeletePlanCommand");
+  }
+};
+
+// src/commands/GetPlanCommand.ts
+
+
+
+var GetPlanCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  UseControlPlaneEndpoint: { type: "staticContextParams", value: true }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "GetPlan", {}).n("ARCRegionSwitchClient", "GetPlanCommand").f(void 0, void 0).ser(se_GetPlanCommand).de(de_GetPlanCommand).build() {
+  static {
+    __name(this, "GetPlanCommand");
+  }
+};
+
+// src/commands/GetPlanEvaluationStatusCommand.ts
+
+
+
+var GetPlanEvaluationStatusCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "GetPlanEvaluationStatus", {}).n("ARCRegionSwitchClient", "GetPlanEvaluationStatusCommand").f(void 0, void 0).ser(se_GetPlanEvaluationStatusCommand).de(de_GetPlanEvaluationStatusCommand).build() {
+  static {
+    __name(this, "GetPlanEvaluationStatusCommand");
+  }
+};
+
+// src/commands/GetPlanExecutionCommand.ts
+
+
+
+var GetPlanExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "GetPlanExecution", {}).n("ARCRegionSwitchClient", "GetPlanExecutionCommand").f(void 0, void 0).ser(se_GetPlanExecutionCommand).de(de_GetPlanExecutionCommand).build() {
+  static {
+    __name(this, "GetPlanExecutionCommand");
+  }
+};
+
+// src/commands/GetPlanInRegionCommand.ts
+
+
+
+var GetPlanInRegionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "GetPlanInRegion", {}).n("ARCRegionSwitchClient", "GetPlanInRegionCommand").f(void 0, void 0).ser(se_GetPlanInRegionCommand).de(de_GetPlanInRegionCommand).build() {
+  static {
+    __name(this, "GetPlanInRegionCommand");
+  }
+};
+
+// src/commands/ListPlanExecutionEventsCommand.ts
+
+
+
+var ListPlanExecutionEventsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "ListPlanExecutionEvents", {}).n("ARCRegionSwitchClient", "ListPlanExecutionEventsCommand").f(void 0, void 0).ser(se_ListPlanExecutionEventsCommand).de(de_ListPlanExecutionEventsCommand).build() {
+  static {
+    __name(this, "ListPlanExecutionEventsCommand");
+  }
+};
+
+// src/commands/ListPlanExecutionsCommand.ts
+
+
+
+var ListPlanExecutionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "ListPlanExecutions", {}).n("ARCRegionSwitchClient", "ListPlanExecutionsCommand").f(void 0, void 0).ser(se_ListPlanExecutionsCommand).de(de_ListPlanExecutionsCommand).build() {
+  static {
+    __name(this, "ListPlanExecutionsCommand");
+  }
+};
+
+// src/commands/ListPlansCommand.ts
+
+
+
+var ListPlansCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  UseControlPlaneEndpoint: { type: "staticContextParams", value: true }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "ListPlans", {}).n("ARCRegionSwitchClient", "ListPlansCommand").f(void 0, void 0).ser(se_ListPlansCommand).de(de_ListPlansCommand).build() {
+  static {
+    __name(this, "ListPlansCommand");
+  }
+};
+
+// src/commands/ListPlansInRegionCommand.ts
+
+
+
+var ListPlansInRegionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "ListPlansInRegion", {}).n("ARCRegionSwitchClient", "ListPlansInRegionCommand").f(void 0, void 0).ser(se_ListPlansInRegionCommand).de(de_ListPlansInRegionCommand).build() {
+  static {
+    __name(this, "ListPlansInRegionCommand");
+  }
+};
+
+// src/commands/ListRoute53HealthChecksCommand.ts
+
+
+
+var ListRoute53HealthChecksCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  UseControlPlaneEndpoint: { type: "staticContextParams", value: true }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "ListRoute53HealthChecks", {}).n("ARCRegionSwitchClient", "ListRoute53HealthChecksCommand").f(void 0, void 0).ser(se_ListRoute53HealthChecksCommand).de(de_ListRoute53HealthChecksCommand).build() {
+  static {
+    __name(this, "ListRoute53HealthChecksCommand");
+  }
+};
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  UseControlPlaneEndpoint: { type: "staticContextParams", value: true }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "ListTagsForResource", {}).n("ARCRegionSwitchClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+  static {
+    __name(this, "ListTagsForResourceCommand");
+  }
+};
+
+// src/commands/StartPlanExecutionCommand.ts
+
+
+
+var StartPlanExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "StartPlanExecution", {}).n("ARCRegionSwitchClient", "StartPlanExecutionCommand").f(void 0, void 0).ser(se_StartPlanExecutionCommand).de(de_StartPlanExecutionCommand).build() {
+  static {
+    __name(this, "StartPlanExecutionCommand");
+  }
+};
+
+// src/commands/TagResourceCommand.ts
+
+
+
+var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  UseControlPlaneEndpoint: { type: "staticContextParams", value: true }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "TagResource", {}).n("ARCRegionSwitchClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+  static {
+    __name(this, "TagResourceCommand");
+  }
+};
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  UseControlPlaneEndpoint: { type: "staticContextParams", value: true }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "UntagResource", {}).n("ARCRegionSwitchClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+  static {
+    __name(this, "UntagResourceCommand");
+  }
+};
+
+// src/commands/UpdatePlanCommand.ts
+
+
+
+var UpdatePlanCommand = class extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  UseControlPlaneEndpoint: { type: "staticContextParams", value: true }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "UpdatePlan", {}).n("ARCRegionSwitchClient", "UpdatePlanCommand").f(void 0, void 0).ser(se_UpdatePlanCommand).de(de_UpdatePlanCommand).build() {
+  static {
+    __name(this, "UpdatePlanCommand");
+  }
+};
+
+// src/commands/UpdatePlanExecutionCommand.ts
+
+
+
+var UpdatePlanExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "UpdatePlanExecution", {}).n("ARCRegionSwitchClient", "UpdatePlanExecutionCommand").f(void 0, void 0).ser(se_UpdatePlanExecutionCommand).de(de_UpdatePlanExecutionCommand).build() {
+  static {
+    __name(this, "UpdatePlanExecutionCommand");
+  }
+};
+
+// src/commands/UpdatePlanExecutionStepCommand.ts
+
+
+
+var UpdatePlanExecutionStepCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ArcRegionSwitch", "UpdatePlanExecutionStep", {}).n("ARCRegionSwitchClient", "UpdatePlanExecutionStepCommand").f(void 0, void 0).ser(se_UpdatePlanExecutionStepCommand).de(de_UpdatePlanExecutionStepCommand).build() {
+  static {
+    __name(this, "UpdatePlanExecutionStepCommand");
+  }
+};
+
+// src/ARCRegionSwitch.ts
+var commands = {
+  ApprovePlanExecutionStepCommand,
+  CancelPlanExecutionCommand,
+  CreatePlanCommand,
+  DeletePlanCommand,
+  GetPlanCommand,
+  GetPlanEvaluationStatusCommand,
+  GetPlanExecutionCommand,
+  GetPlanInRegionCommand,
+  ListPlanExecutionEventsCommand,
+  ListPlanExecutionsCommand,
+  ListPlansCommand,
+  ListPlansInRegionCommand,
+  ListRoute53HealthChecksCommand,
+  ListTagsForResourceCommand,
+  StartPlanExecutionCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdatePlanCommand,
+  UpdatePlanExecutionCommand,
+  UpdatePlanExecutionStepCommand
+};
+var ARCRegionSwitch = class extends ARCRegionSwitchClient {
+  static {
+    __name(this, "ARCRegionSwitch");
+  }
+};
+(0, import_smithy_client.createAggregatedClient)(commands, ARCRegionSwitch);
+
+// src/pagination/GetPlanEvaluationStatusPaginator.ts
+
+var paginateGetPlanEvaluationStatus = (0, import_core.createPaginator)(ARCRegionSwitchClient, GetPlanEvaluationStatusCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/GetPlanExecutionPaginator.ts
+
+var paginateGetPlanExecution = (0, import_core.createPaginator)(ARCRegionSwitchClient, GetPlanExecutionCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListPlanExecutionEventsPaginator.ts
+
+var paginateListPlanExecutionEvents = (0, import_core.createPaginator)(ARCRegionSwitchClient, ListPlanExecutionEventsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListPlanExecutionsPaginator.ts
+
+var paginateListPlanExecutions = (0, import_core.createPaginator)(ARCRegionSwitchClient, ListPlanExecutionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListPlansInRegionPaginator.ts
+
+var paginateListPlansInRegion = (0, import_core.createPaginator)(ARCRegionSwitchClient, ListPlansInRegionCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListPlansPaginator.ts
+
+var paginateListPlans = (0, import_core.createPaginator)(ARCRegionSwitchClient, ListPlansCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListRoute53HealthChecksPaginator.ts
+
+var paginateListRoute53HealthChecks = (0, import_core.createPaginator)(ARCRegionSwitchClient, ListRoute53HealthChecksCommand, "nextToken", "nextToken", "maxResults");
+
+// src/waiters/waitForPlanEvaluationStatusPassed.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetPlanEvaluationStatusCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.evaluationState;
+      }, "returnComparator");
+      if (returnComparator() === "passed") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.evaluationState;
+      }, "returnComparator");
+      if (returnComparator() === "actionRequired") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.evaluationState;
+      }, "returnComparator");
+      if (returnComparator() === "pendingEvaluation") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForPlanEvaluationStatusPassed = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForPlanEvaluationStatusPassed");
+var waitUntilPlanEvaluationStatusPassed = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilPlanEvaluationStatusPassed");
+
+// src/waiters/waitForPlanExecutionCompleted.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetPlanExecutionCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.executionState;
+      }, "returnComparator");
+      if (returnComparator() === "completed") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.executionState;
+      }, "returnComparator");
+      if (returnComparator() === "completedWithExceptions") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.executionState;
+      }, "returnComparator");
+      if (returnComparator() === "failed") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.executionState;
+      }, "returnComparator");
+      if (returnComparator() === "canceled") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.executionState;
+      }, "returnComparator");
+      if (returnComparator() === "planExecutionTimedOut") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForPlanExecutionCompleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForPlanExecutionCompleted");
+var waitUntilPlanExecutionCompleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilPlanExecutionCompleted");
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  ARCRegionSwitchServiceException,
+  __Client,
+  ARCRegionSwitchClient,
+  ARCRegionSwitch,
+  $Command,
+  ApprovePlanExecutionStepCommand,
+  CancelPlanExecutionCommand,
+  CreatePlanCommand,
+  DeletePlanCommand,
+  GetPlanCommand,
+  GetPlanEvaluationStatusCommand,
+  GetPlanExecutionCommand,
+  GetPlanInRegionCommand,
+  ListPlanExecutionEventsCommand,
+  ListPlanExecutionsCommand,
+  ListPlansCommand,
+  ListPlansInRegionCommand,
+  ListRoute53HealthChecksCommand,
+  ListTagsForResourceCommand,
+  StartPlanExecutionCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdatePlanCommand,
+  UpdatePlanExecutionCommand,
+  UpdatePlanExecutionStepCommand,
+  paginateGetPlanEvaluationStatus,
+  paginateGetPlanExecution,
+  paginateListPlanExecutionEvents,
+  paginateListPlanExecutions,
+  paginateListPlansInRegion,
+  paginateListPlans,
+  paginateListRoute53HealthChecks,
+  waitForPlanEvaluationStatusPassed,
+  waitUntilPlanEvaluationStatusPassed,
+  waitForPlanExecutionCompleted,
+  waitUntilPlanExecutionCompleted,
+  ExecutionAction,
+  ExecutionState,
+  ExecutionMode,
+  RecoveryApproach,
+  AccessDeniedException,
+  AlarmCondition,
+  AlarmType,
+  Approval,
+  ResourceNotFoundException,
+  EvaluationStatus,
+  ResourceWarningStatus,
+  WorkflowTargetAction,
+  RoutingControlStateChange,
+  RegionToRunIn,
+  LambdaUngracefulBehavior,
+  Ec2AsgCapacityMonitoringApproach,
+  EcsCapacityMonitoringApproach,
+  EksCapacityMonitoringApproach,
+  GlobalAuroraDefaultBehavior,
+  GlobalAuroraUngracefulBehavior,
+  ExecutionBlockType,
+  StepStatus,
+  ExecutionEventType,
+  InternalServerException,
+  IllegalStateException,
+  IllegalArgumentException,
+  UpdatePlanExecutionAction,
+  UpdatePlanExecutionStepAction,
+  ExecutionBlockConfiguration
+});
+