@aws-sdk/client-route53-recovery-readiness 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,12 +1,3177 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Route53RecoveryReadinessServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./Route53RecoveryReadinessClient"), exports);
-tslib_1.__exportStar(require("./Route53RecoveryReadiness"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var Route53RecoveryReadinessServiceException_1 = require("./models/Route53RecoveryReadinessServiceException");
-Object.defineProperty(exports, "Route53RecoveryReadinessServiceException", { enumerable: true, get: function () { return Route53RecoveryReadinessServiceException_1.Route53RecoveryReadinessServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  ConflictException: () => ConflictException,
+  CreateCellCommand: () => CreateCellCommand,
+  CreateCrossAccountAuthorizationCommand: () => CreateCrossAccountAuthorizationCommand,
+  CreateReadinessCheckCommand: () => CreateReadinessCheckCommand,
+  CreateRecoveryGroupCommand: () => CreateRecoveryGroupCommand,
+  CreateResourceSetCommand: () => CreateResourceSetCommand,
+  DeleteCellCommand: () => DeleteCellCommand,
+  DeleteCrossAccountAuthorizationCommand: () => DeleteCrossAccountAuthorizationCommand,
+  DeleteReadinessCheckCommand: () => DeleteReadinessCheckCommand,
+  DeleteRecoveryGroupCommand: () => DeleteRecoveryGroupCommand,
+  DeleteResourceSetCommand: () => DeleteResourceSetCommand,
+  GetArchitectureRecommendationsCommand: () => GetArchitectureRecommendationsCommand,
+  GetCellCommand: () => GetCellCommand,
+  GetCellReadinessSummaryCommand: () => GetCellReadinessSummaryCommand,
+  GetReadinessCheckCommand: () => GetReadinessCheckCommand,
+  GetReadinessCheckResourceStatusCommand: () => GetReadinessCheckResourceStatusCommand,
+  GetReadinessCheckStatusCommand: () => GetReadinessCheckStatusCommand,
+  GetRecoveryGroupCommand: () => GetRecoveryGroupCommand,
+  GetRecoveryGroupReadinessSummaryCommand: () => GetRecoveryGroupReadinessSummaryCommand,
+  GetResourceSetCommand: () => GetResourceSetCommand,
+  InternalServerException: () => InternalServerException,
+  ListCellsCommand: () => ListCellsCommand,
+  ListCrossAccountAuthorizationsCommand: () => ListCrossAccountAuthorizationsCommand,
+  ListReadinessChecksCommand: () => ListReadinessChecksCommand,
+  ListRecoveryGroupsCommand: () => ListRecoveryGroupsCommand,
+  ListResourceSetsCommand: () => ListResourceSetsCommand,
+  ListRulesCommand: () => ListRulesCommand,
+  ListTagsForResourcesCommand: () => ListTagsForResourcesCommand,
+  Readiness: () => Readiness,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  Route53RecoveryReadiness: () => Route53RecoveryReadiness,
+  Route53RecoveryReadinessClient: () => Route53RecoveryReadinessClient,
+  Route53RecoveryReadinessServiceException: () => Route53RecoveryReadinessServiceException,
+  TagResourceCommand: () => TagResourceCommand,
+  ThrottlingException: () => ThrottlingException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateCellCommand: () => UpdateCellCommand,
+  UpdateReadinessCheckCommand: () => UpdateReadinessCheckCommand,
+  UpdateRecoveryGroupCommand: () => UpdateRecoveryGroupCommand,
+  UpdateResourceSetCommand: () => UpdateResourceSetCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateGetCellReadinessSummary: () => paginateGetCellReadinessSummary,
+  paginateGetReadinessCheckResourceStatus: () => paginateGetReadinessCheckResourceStatus,
+  paginateGetReadinessCheckStatus: () => paginateGetReadinessCheckStatus,
+  paginateGetRecoveryGroupReadinessSummary: () => paginateGetRecoveryGroupReadinessSummary,
+  paginateListCells: () => paginateListCells,
+  paginateListCrossAccountAuthorizations: () => paginateListCrossAccountAuthorizations,
+  paginateListReadinessChecks: () => paginateListReadinessChecks,
+  paginateListRecoveryGroups: () => paginateListRecoveryGroups,
+  paginateListResourceSets: () => paginateListResourceSets,
+  paginateListRules: () => paginateListRules
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Route53RecoveryReadinessClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "route53-recovery-readiness"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/Route53RecoveryReadinessClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/Route53RecoveryReadinessClient.ts
+var _Route53RecoveryReadinessClient = class _Route53RecoveryReadinessClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_Route53RecoveryReadinessClient, "Route53RecoveryReadinessClient");
+var Route53RecoveryReadinessClient = _Route53RecoveryReadinessClient;
+
+// src/Route53RecoveryReadiness.ts
+
+
+// src/commands/CreateCellCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+
+// src/models/Route53RecoveryReadinessServiceException.ts
+
+var _Route53RecoveryReadinessServiceException = class _Route53RecoveryReadinessServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _Route53RecoveryReadinessServiceException.prototype);
+  }
+};
+__name(_Route53RecoveryReadinessServiceException, "Route53RecoveryReadinessServiceException");
+var Route53RecoveryReadinessServiceException = _Route53RecoveryReadinessServiceException;
+
+// src/models/models_0.ts
+var Readiness = {
+  NOT_AUTHORIZED: "NOT_AUTHORIZED",
+  NOT_READY: "NOT_READY",
+  READY: "READY",
+  UNKNOWN: "UNKNOWN"
+};
+var _AccessDeniedException = class _AccessDeniedException extends Route53RecoveryReadinessServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var _ConflictException = class _ConflictException extends Route53RecoveryReadinessServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _InternalServerException = class _InternalServerException extends Route53RecoveryReadinessServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _ThrottlingException = class _ThrottlingException extends Route53RecoveryReadinessServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _ValidationException = class _ValidationException extends Route53RecoveryReadinessServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends Route53RecoveryReadinessServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateCellCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/cells");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      cellName: [, , `CellName`],
+      cells: [, (_) => (0, import_smithy_client._json)(_), `Cells`],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateCellCommand");
+var se_CreateCrossAccountAuthorizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/crossaccountauthorizations");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      crossAccountAuthorization: [, , `CrossAccountAuthorization`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateCrossAccountAuthorizationCommand");
+var se_CreateReadinessCheckCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/readinesschecks");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      readinessCheckName: [, , `ReadinessCheckName`],
+      resourceSetName: [, , `ResourceSetName`],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateReadinessCheckCommand");
+var se_CreateRecoveryGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/recoverygroups");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      cells: [, (_) => (0, import_smithy_client._json)(_), `Cells`],
+      recoveryGroupName: [, , `RecoveryGroupName`],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateRecoveryGroupCommand");
+var se_CreateResourceSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/resourcesets");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceSetName: [, , `ResourceSetName`],
+      resourceSetType: [, , `ResourceSetType`],
+      resources: [, (_) => se___listOfResource(_, context), `Resources`],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateResourceSetCommand");
+var se_DeleteCellCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/cells/{CellName}");
+  b.p("CellName", () => input.CellName, "{CellName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteCellCommand");
+var se_DeleteCrossAccountAuthorizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/crossaccountauthorizations/{CrossAccountAuthorization}");
+  b.p("CrossAccountAuthorization", () => input.CrossAccountAuthorization, "{CrossAccountAuthorization}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteCrossAccountAuthorizationCommand");
+var se_DeleteReadinessCheckCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/readinesschecks/{ReadinessCheckName}");
+  b.p("ReadinessCheckName", () => input.ReadinessCheckName, "{ReadinessCheckName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteReadinessCheckCommand");
+var se_DeleteRecoveryGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/recoverygroups/{RecoveryGroupName}");
+  b.p("RecoveryGroupName", () => input.RecoveryGroupName, "{RecoveryGroupName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteRecoveryGroupCommand");
+var se_DeleteResourceSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/resourcesets/{ResourceSetName}");
+  b.p("ResourceSetName", () => input.ResourceSetName, "{ResourceSetName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteResourceSetCommand");
+var se_GetArchitectureRecommendationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/recoverygroups/{RecoveryGroupName}/architectureRecommendations");
+  b.p("RecoveryGroupName", () => input.RecoveryGroupName, "{RecoveryGroupName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetArchitectureRecommendationsCommand");
+var se_GetCellCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/cells/{CellName}");
+  b.p("CellName", () => input.CellName, "{CellName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetCellCommand");
+var se_GetCellReadinessSummaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/cellreadiness/{CellName}");
+  b.p("CellName", () => input.CellName, "{CellName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetCellReadinessSummaryCommand");
+var se_GetReadinessCheckCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/readinesschecks/{ReadinessCheckName}");
+  b.p("ReadinessCheckName", () => input.ReadinessCheckName, "{ReadinessCheckName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetReadinessCheckCommand");
+var se_GetReadinessCheckResourceStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/readinesschecks/{ReadinessCheckName}/resource/{ResourceIdentifier}/status");
+  b.p("ReadinessCheckName", () => input.ReadinessCheckName, "{ReadinessCheckName}", false);
+  b.p("ResourceIdentifier", () => input.ResourceIdentifier, "{ResourceIdentifier}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetReadinessCheckResourceStatusCommand");
+var se_GetReadinessCheckStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/readinesschecks/{ReadinessCheckName}/status");
+  b.p("ReadinessCheckName", () => input.ReadinessCheckName, "{ReadinessCheckName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetReadinessCheckStatusCommand");
+var se_GetRecoveryGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/recoverygroups/{RecoveryGroupName}");
+  b.p("RecoveryGroupName", () => input.RecoveryGroupName, "{RecoveryGroupName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetRecoveryGroupCommand");
+var se_GetRecoveryGroupReadinessSummaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/recoverygroupreadiness/{RecoveryGroupName}");
+  b.p("RecoveryGroupName", () => input.RecoveryGroupName, "{RecoveryGroupName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetRecoveryGroupReadinessSummaryCommand");
+var se_GetResourceSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/resourcesets/{ResourceSetName}");
+  b.p("ResourceSetName", () => input.ResourceSetName, "{ResourceSetName}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetResourceSetCommand");
+var se_ListCellsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/cells");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListCellsCommand");
+var se_ListCrossAccountAuthorizationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/crossaccountauthorizations");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListCrossAccountAuthorizationsCommand");
+var se_ListReadinessChecksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/readinesschecks");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListReadinessChecksCommand");
+var se_ListRecoveryGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/recoverygroups");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListRecoveryGroupsCommand");
+var se_ListResourceSetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/resourcesets");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListResourceSetsCommand");
+var se_ListRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/rules");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]],
+    [_rT]: [, input[_RT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListRulesCommand");
+var se_ListTagsForResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{ResourceArn}");
+  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourcesCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tags/{ResourceArn}");
+  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{ResourceArn}");
+  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.TagKeys, `TagKeys`) != null,
+      () => (input[_TK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateCellCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/cells/{CellName}");
+  b.p("CellName", () => input.CellName, "{CellName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      cells: [, (_) => (0, import_smithy_client._json)(_), `Cells`]
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateCellCommand");
+var se_UpdateReadinessCheckCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/readinesschecks/{ReadinessCheckName}");
+  b.p("ReadinessCheckName", () => input.ReadinessCheckName, "{ReadinessCheckName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceSetName: [, , `ResourceSetName`]
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateReadinessCheckCommand");
+var se_UpdateRecoveryGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/recoverygroups/{RecoveryGroupName}");
+  b.p("RecoveryGroupName", () => input.RecoveryGroupName, "{RecoveryGroupName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      cells: [, (_) => (0, import_smithy_client._json)(_), `Cells`]
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateRecoveryGroupCommand");
+var se_UpdateResourceSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/resourcesets/{ResourceSetName}");
+  b.p("ResourceSetName", () => input.ResourceSetName, "{ResourceSetName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceSetType: [, , `ResourceSetType`],
+      resources: [, (_) => se___listOfResource(_, context), `Resources`]
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateResourceSetCommand");
+var de_CreateCellCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateCellCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    CellArn: [, import_smithy_client.expectString, `cellArn`],
+    CellName: [, import_smithy_client.expectString, `cellName`],
+    Cells: [, import_smithy_client._json, `cells`],
+    ParentReadinessScopes: [, import_smithy_client._json, `parentReadinessScopes`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateCellCommand");
+var de_CreateCellCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.route53recoveryreadiness#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCellCommandError");
+var de_CreateCrossAccountAuthorizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateCrossAccountAuthorizationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    CrossAccountAuthorization: [, import_smithy_client.expectString, `crossAccountAuthorization`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateCrossAccountAuthorizationCommand");
+var de_CreateCrossAccountAuthorizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.route53recoveryreadiness#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCrossAccountAuthorizationCommandError");
+var de_CreateReadinessCheckCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateReadinessCheckCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ReadinessCheckArn: [, import_smithy_client.expectString, `readinessCheckArn`],
+    ReadinessCheckName: [, import_smithy_client.expectString, `readinessCheckName`],
+    ResourceSet: [, import_smithy_client.expectString, `resourceSet`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateReadinessCheckCommand");
+var de_CreateReadinessCheckCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.route53recoveryreadiness#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateReadinessCheckCommandError");
+var de_CreateRecoveryGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateRecoveryGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Cells: [, import_smithy_client._json, `cells`],
+    RecoveryGroupArn: [, import_smithy_client.expectString, `recoveryGroupArn`],
+    RecoveryGroupName: [, import_smithy_client.expectString, `recoveryGroupName`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateRecoveryGroupCommand");
+var de_CreateRecoveryGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.route53recoveryreadiness#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateRecoveryGroupCommandError");
+var de_CreateResourceSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateResourceSetCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ResourceSetArn: [, import_smithy_client.expectString, `resourceSetArn`],
+    ResourceSetName: [, import_smithy_client.expectString, `resourceSetName`],
+    ResourceSetType: [, import_smithy_client.expectString, `resourceSetType`],
+    Resources: [, (_) => de___listOfResource(_, context), `resources`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateResourceSetCommand");
+var de_CreateResourceSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.route53recoveryreadiness#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateResourceSetCommandError");
+var de_DeleteCellCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteCellCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteCellCommand");
+var de_DeleteCellCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteCellCommandError");
+var de_DeleteCrossAccountAuthorizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteCrossAccountAuthorizationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteCrossAccountAuthorizationCommand");
+var de_DeleteCrossAccountAuthorizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteCrossAccountAuthorizationCommandError");
+var de_DeleteReadinessCheckCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteReadinessCheckCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteReadinessCheckCommand");
+var de_DeleteReadinessCheckCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteReadinessCheckCommandError");
+var de_DeleteRecoveryGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteRecoveryGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteRecoveryGroupCommand");
+var de_DeleteRecoveryGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRecoveryGroupCommandError");
+var de_DeleteResourceSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteResourceSetCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteResourceSetCommand");
+var de_DeleteResourceSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteResourceSetCommandError");
+var de_GetArchitectureRecommendationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetArchitectureRecommendationsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    LastAuditTimestamp: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `lastAuditTimestamp`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    Recommendations: [, (_) => de___listOfRecommendation(_, context), `recommendations`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetArchitectureRecommendationsCommand");
+var de_GetArchitectureRecommendationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetArchitectureRecommendationsCommandError");
+var de_GetCellCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetCellCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    CellArn: [, import_smithy_client.expectString, `cellArn`],
+    CellName: [, import_smithy_client.expectString, `cellName`],
+    Cells: [, import_smithy_client._json, `cells`],
+    ParentReadinessScopes: [, import_smithy_client._json, `parentReadinessScopes`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetCellCommand");
+var de_GetCellCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCellCommandError");
+var de_GetCellReadinessSummaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetCellReadinessSummaryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    Readiness: [, import_smithy_client.expectString, `readiness`],
+    ReadinessChecks: [, (_) => de___listOfReadinessCheckSummary(_, context), `readinessChecks`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetCellReadinessSummaryCommand");
+var de_GetCellReadinessSummaryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCellReadinessSummaryCommandError");
+var de_GetReadinessCheckCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetReadinessCheckCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ReadinessCheckArn: [, import_smithy_client.expectString, `readinessCheckArn`],
+    ReadinessCheckName: [, import_smithy_client.expectString, `readinessCheckName`],
+    ResourceSet: [, import_smithy_client.expectString, `resourceSet`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetReadinessCheckCommand");
+var de_GetReadinessCheckCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetReadinessCheckCommandError");
+var de_GetReadinessCheckResourceStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetReadinessCheckResourceStatusCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    Readiness: [, import_smithy_client.expectString, `readiness`],
+    Rules: [, (_) => de___listOfRuleResult(_, context), `rules`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetReadinessCheckResourceStatusCommand");
+var de_GetReadinessCheckResourceStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetReadinessCheckResourceStatusCommandError");
+var de_GetReadinessCheckStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetReadinessCheckStatusCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Messages: [, (_) => de___listOfMessage(_, context), `messages`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    Readiness: [, import_smithy_client.expectString, `readiness`],
+    Resources: [, (_) => de___listOfResourceResult(_, context), `resources`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetReadinessCheckStatusCommand");
+var de_GetReadinessCheckStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetReadinessCheckStatusCommandError");
+var de_GetRecoveryGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetRecoveryGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Cells: [, import_smithy_client._json, `cells`],
+    RecoveryGroupArn: [, import_smithy_client.expectString, `recoveryGroupArn`],
+    RecoveryGroupName: [, import_smithy_client.expectString, `recoveryGroupName`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetRecoveryGroupCommand");
+var de_GetRecoveryGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetRecoveryGroupCommandError");
+var de_GetRecoveryGroupReadinessSummaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetRecoveryGroupReadinessSummaryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    Readiness: [, import_smithy_client.expectString, `readiness`],
+    ReadinessChecks: [, (_) => de___listOfReadinessCheckSummary(_, context), `readinessChecks`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetRecoveryGroupReadinessSummaryCommand");
+var de_GetRecoveryGroupReadinessSummaryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetRecoveryGroupReadinessSummaryCommandError");
+var de_GetResourceSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetResourceSetCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ResourceSetArn: [, import_smithy_client.expectString, `resourceSetArn`],
+    ResourceSetName: [, import_smithy_client.expectString, `resourceSetName`],
+    ResourceSetType: [, import_smithy_client.expectString, `resourceSetType`],
+    Resources: [, (_) => de___listOfResource(_, context), `resources`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetResourceSetCommand");
+var de_GetResourceSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetResourceSetCommandError");
+var de_ListCellsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListCellsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Cells: [, (_) => de___listOfCellOutput(_, context), `cells`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListCellsCommand");
+var de_ListCellsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCellsCommandError");
+var de_ListCrossAccountAuthorizationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListCrossAccountAuthorizationsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    CrossAccountAuthorizations: [, import_smithy_client._json, `crossAccountAuthorizations`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListCrossAccountAuthorizationsCommand");
+var de_ListCrossAccountAuthorizationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCrossAccountAuthorizationsCommandError");
+var de_ListReadinessChecksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListReadinessChecksCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    ReadinessChecks: [, (_) => de___listOfReadinessCheckOutput(_, context), `readinessChecks`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListReadinessChecksCommand");
+var de_ListReadinessChecksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListReadinessChecksCommandError");
+var de_ListRecoveryGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListRecoveryGroupsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    RecoveryGroups: [, (_) => de___listOfRecoveryGroupOutput(_, context), `recoveryGroups`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListRecoveryGroupsCommand");
+var de_ListRecoveryGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRecoveryGroupsCommandError");
+var de_ListResourceSetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListResourceSetsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    ResourceSets: [, (_) => de___listOfResourceSetOutput(_, context), `resourceSets`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListResourceSetsCommand");
+var de_ListResourceSetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListResourceSetsCommandError");
+var de_ListRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListRulesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    Rules: [, (_) => de___listOfListRulesOutput(_, context), `rules`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListRulesCommand");
+var de_ListRulesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRulesCommandError");
+var de_ListTagsForResourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourcesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourcesCommand");
+var de_ListTagsForResourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourcesCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateCellCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateCellCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    CellArn: [, import_smithy_client.expectString, `cellArn`],
+    CellName: [, import_smithy_client.expectString, `cellName`],
+    Cells: [, import_smithy_client._json, `cells`],
+    ParentReadinessScopes: [, import_smithy_client._json, `parentReadinessScopes`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateCellCommand");
+var de_UpdateCellCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateCellCommandError");
+var de_UpdateReadinessCheckCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateReadinessCheckCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ReadinessCheckArn: [, import_smithy_client.expectString, `readinessCheckArn`],
+    ReadinessCheckName: [, import_smithy_client.expectString, `readinessCheckName`],
+    ResourceSet: [, import_smithy_client.expectString, `resourceSet`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateReadinessCheckCommand");
+var de_UpdateReadinessCheckCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateReadinessCheckCommandError");
+var de_UpdateRecoveryGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateRecoveryGroupCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Cells: [, import_smithy_client._json, `cells`],
+    RecoveryGroupArn: [, import_smithy_client.expectString, `recoveryGroupArn`],
+    RecoveryGroupName: [, import_smithy_client.expectString, `recoveryGroupName`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateRecoveryGroupCommand");
+var de_UpdateRecoveryGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateRecoveryGroupCommandError");
+var de_UpdateResourceSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateResourceSetCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ResourceSetArn: [, import_smithy_client.expectString, `resourceSetArn`],
+    ResourceSetName: [, import_smithy_client.expectString, `resourceSetName`],
+    ResourceSetType: [, import_smithy_client.expectString, `resourceSetType`],
+    Resources: [, (_) => de___listOfResource(_, context), `resources`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateResourceSetCommand");
+var de_UpdateResourceSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.route53recoveryreadiness#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.route53recoveryreadiness#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.route53recoveryreadiness#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.route53recoveryreadiness#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.route53recoveryreadiness#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateResourceSetCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(Route53RecoveryReadinessServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: [, import_smithy_client.expectString, `message`]
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se___listOfResource = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Resource(entry, context);
+  });
+}, "se___listOfResource");
+var se_DNSTargetResource = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    domainName: [, , `DomainName`],
+    hostedZoneArn: [, , `HostedZoneArn`],
+    recordSetId: [, , `RecordSetId`],
+    recordType: [, , `RecordType`],
+    targetResource: [, (_) => se_TargetResource(_, context), `TargetResource`]
+  });
+}, "se_DNSTargetResource");
+var se_NLBResource = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    arn: [, , `Arn`]
+  });
+}, "se_NLBResource");
+var se_R53ResourceRecord = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    domainName: [, , `DomainName`],
+    recordSetId: [, , `RecordSetId`]
+  });
+}, "se_R53ResourceRecord");
+var se_Resource = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    componentId: [, , `ComponentId`],
+    dnsTargetResource: [, (_) => se_DNSTargetResource(_, context), `DnsTargetResource`],
+    readinessScopes: [, import_smithy_client._json, `ReadinessScopes`],
+    resourceArn: [, , `ResourceArn`]
+  });
+}, "se_Resource");
+var se_TargetResource = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    nLBResource: [, (_) => se_NLBResource(_, context), `NLBResource`],
+    r53Resource: [, (_) => se_R53ResourceRecord(_, context), `R53Resource`]
+  });
+}, "se_TargetResource");
+var de___listOfCellOutput = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CellOutput(entry, context);
+  });
+  return retVal;
+}, "de___listOfCellOutput");
+var de___listOfListRulesOutput = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ListRulesOutput(entry, context);
+  });
+  return retVal;
+}, "de___listOfListRulesOutput");
+var de___listOfMessage = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Message(entry, context);
+  });
+  return retVal;
+}, "de___listOfMessage");
+var de___listOfReadinessCheckOutput = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ReadinessCheckOutput(entry, context);
+  });
+  return retVal;
+}, "de___listOfReadinessCheckOutput");
+var de___listOfReadinessCheckSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ReadinessCheckSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfReadinessCheckSummary");
+var de___listOfRecommendation = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Recommendation(entry, context);
+  });
+  return retVal;
+}, "de___listOfRecommendation");
+var de___listOfRecoveryGroupOutput = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RecoveryGroupOutput(entry, context);
+  });
+  return retVal;
+}, "de___listOfRecoveryGroupOutput");
+var de___listOfResource = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Resource(entry, context);
+  });
+  return retVal;
+}, "de___listOfResource");
+var de___listOfResourceResult = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ResourceResult(entry, context);
+  });
+  return retVal;
+}, "de___listOfResourceResult");
+var de___listOfResourceSetOutput = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ResourceSetOutput(entry, context);
+  });
+  return retVal;
+}, "de___listOfResourceSetOutput");
+var de___listOfRuleResult = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RuleResult(entry, context);
+  });
+  return retVal;
+}, "de___listOfRuleResult");
+var de_CellOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CellArn: [, import_smithy_client.expectString, `cellArn`],
+    CellName: [, import_smithy_client.expectString, `cellName`],
+    Cells: [, import_smithy_client._json, `cells`],
+    ParentReadinessScopes: [, import_smithy_client._json, `parentReadinessScopes`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+}, "de_CellOutput");
+var de_DNSTargetResource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DomainName: [, import_smithy_client.expectString, `domainName`],
+    HostedZoneArn: [, import_smithy_client.expectString, `hostedZoneArn`],
+    RecordSetId: [, import_smithy_client.expectString, `recordSetId`],
+    RecordType: [, import_smithy_client.expectString, `recordType`],
+    TargetResource: [, (_) => de_TargetResource(_, context), `targetResource`]
+  });
+}, "de_DNSTargetResource");
+var de_ListRulesOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ResourceType: [, import_smithy_client.expectString, `resourceType`],
+    RuleDescription: [, import_smithy_client.expectString, `ruleDescription`],
+    RuleId: [, import_smithy_client.expectString, `ruleId`]
+  });
+}, "de_ListRulesOutput");
+var de_Message = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MessageText: [, import_smithy_client.expectString, `messageText`]
+  });
+}, "de_Message");
+var de_NLBResource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: [, import_smithy_client.expectString, `arn`]
+  });
+}, "de_NLBResource");
+var de_R53ResourceRecord = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DomainName: [, import_smithy_client.expectString, `domainName`],
+    RecordSetId: [, import_smithy_client.expectString, `recordSetId`]
+  });
+}, "de_R53ResourceRecord");
+var de_ReadinessCheckOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ReadinessCheckArn: [, import_smithy_client.expectString, `readinessCheckArn`],
+    ReadinessCheckName: [, import_smithy_client.expectString, `readinessCheckName`],
+    ResourceSet: [, import_smithy_client.expectString, `resourceSet`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+}, "de_ReadinessCheckOutput");
+var de_ReadinessCheckSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Readiness: [, import_smithy_client.expectString, `readiness`],
+    ReadinessCheckName: [, import_smithy_client.expectString, `readinessCheckName`]
+  });
+}, "de_ReadinessCheckSummary");
+var de_Recommendation = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    RecommendationText: [, import_smithy_client.expectString, `recommendationText`]
+  });
+}, "de_Recommendation");
+var de_RecoveryGroupOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cells: [, import_smithy_client._json, `cells`],
+    RecoveryGroupArn: [, import_smithy_client.expectString, `recoveryGroupArn`],
+    RecoveryGroupName: [, import_smithy_client.expectString, `recoveryGroupName`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+}, "de_RecoveryGroupOutput");
+var de_Resource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ComponentId: [, import_smithy_client.expectString, `componentId`],
+    DnsTargetResource: [, (_) => de_DNSTargetResource(_, context), `dnsTargetResource`],
+    ReadinessScopes: [, import_smithy_client._json, `readinessScopes`],
+    ResourceArn: [, import_smithy_client.expectString, `resourceArn`]
+  });
+}, "de_Resource");
+var de_ResourceResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ComponentId: [, import_smithy_client.expectString, `componentId`],
+    LastCheckedTimestamp: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `lastCheckedTimestamp`],
+    Readiness: [, import_smithy_client.expectString, `readiness`],
+    ResourceArn: [, import_smithy_client.expectString, `resourceArn`]
+  });
+}, "de_ResourceResult");
+var de_ResourceSetOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ResourceSetArn: [, import_smithy_client.expectString, `resourceSetArn`],
+    ResourceSetName: [, import_smithy_client.expectString, `resourceSetName`],
+    ResourceSetType: [, import_smithy_client.expectString, `resourceSetType`],
+    Resources: [, (_) => de___listOfResource(_, context), `resources`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+}, "de_ResourceSetOutput");
+var de_RuleResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LastCheckedTimestamp: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `lastCheckedTimestamp`],
+    Messages: [, (_) => de___listOfMessage(_, context), `messages`],
+    Readiness: [, import_smithy_client.expectString, `readiness`],
+    RuleId: [, import_smithy_client.expectString, `ruleId`]
+  });
+}, "de_RuleResult");
+var de_TargetResource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NLBResource: [, (_) => de_NLBResource(_, context), `nLBResource`],
+    R53Resource: [, (_) => de_R53ResourceRecord(_, context), `r53Resource`]
+  });
+}, "de_TargetResource");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var _MR = "MaxResults";
+var _NT = "NextToken";
+var _RT = "ResourceType";
+var _TK = "TagKeys";
+var _mR = "maxResults";
+var _nT = "nextToken";
+var _rT = "resourceType";
+var _tK = "tagKeys";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CreateCellCommand.ts
+var _CreateCellCommand = class _CreateCellCommand 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("Route53RecoveryReadiness", "CreateCell", {}).n("Route53RecoveryReadinessClient", "CreateCellCommand").f(void 0, void 0).ser(se_CreateCellCommand).de(de_CreateCellCommand).build() {
+};
+__name(_CreateCellCommand, "CreateCellCommand");
+var CreateCellCommand = _CreateCellCommand;
+
+// src/commands/CreateCrossAccountAuthorizationCommand.ts
+
+
+
+
+var _CreateCrossAccountAuthorizationCommand = class _CreateCrossAccountAuthorizationCommand 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("Route53RecoveryReadiness", "CreateCrossAccountAuthorization", {}).n("Route53RecoveryReadinessClient", "CreateCrossAccountAuthorizationCommand").f(void 0, void 0).ser(se_CreateCrossAccountAuthorizationCommand).de(de_CreateCrossAccountAuthorizationCommand).build() {
+};
+__name(_CreateCrossAccountAuthorizationCommand, "CreateCrossAccountAuthorizationCommand");
+var CreateCrossAccountAuthorizationCommand = _CreateCrossAccountAuthorizationCommand;
+
+// src/commands/CreateReadinessCheckCommand.ts
+
+
+
+
+var _CreateReadinessCheckCommand = class _CreateReadinessCheckCommand 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("Route53RecoveryReadiness", "CreateReadinessCheck", {}).n("Route53RecoveryReadinessClient", "CreateReadinessCheckCommand").f(void 0, void 0).ser(se_CreateReadinessCheckCommand).de(de_CreateReadinessCheckCommand).build() {
+};
+__name(_CreateReadinessCheckCommand, "CreateReadinessCheckCommand");
+var CreateReadinessCheckCommand = _CreateReadinessCheckCommand;
+
+// src/commands/CreateRecoveryGroupCommand.ts
+
+
+
+
+var _CreateRecoveryGroupCommand = class _CreateRecoveryGroupCommand 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("Route53RecoveryReadiness", "CreateRecoveryGroup", {}).n("Route53RecoveryReadinessClient", "CreateRecoveryGroupCommand").f(void 0, void 0).ser(se_CreateRecoveryGroupCommand).de(de_CreateRecoveryGroupCommand).build() {
+};
+__name(_CreateRecoveryGroupCommand, "CreateRecoveryGroupCommand");
+var CreateRecoveryGroupCommand = _CreateRecoveryGroupCommand;
+
+// src/commands/CreateResourceSetCommand.ts
+
+
+
+
+var _CreateResourceSetCommand = class _CreateResourceSetCommand 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("Route53RecoveryReadiness", "CreateResourceSet", {}).n("Route53RecoveryReadinessClient", "CreateResourceSetCommand").f(void 0, void 0).ser(se_CreateResourceSetCommand).de(de_CreateResourceSetCommand).build() {
+};
+__name(_CreateResourceSetCommand, "CreateResourceSetCommand");
+var CreateResourceSetCommand = _CreateResourceSetCommand;
+
+// src/commands/DeleteCellCommand.ts
+
+
+
+
+var _DeleteCellCommand = class _DeleteCellCommand 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("Route53RecoveryReadiness", "DeleteCell", {}).n("Route53RecoveryReadinessClient", "DeleteCellCommand").f(void 0, void 0).ser(se_DeleteCellCommand).de(de_DeleteCellCommand).build() {
+};
+__name(_DeleteCellCommand, "DeleteCellCommand");
+var DeleteCellCommand = _DeleteCellCommand;
+
+// src/commands/DeleteCrossAccountAuthorizationCommand.ts
+
+
+
+
+var _DeleteCrossAccountAuthorizationCommand = class _DeleteCrossAccountAuthorizationCommand 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("Route53RecoveryReadiness", "DeleteCrossAccountAuthorization", {}).n("Route53RecoveryReadinessClient", "DeleteCrossAccountAuthorizationCommand").f(void 0, void 0).ser(se_DeleteCrossAccountAuthorizationCommand).de(de_DeleteCrossAccountAuthorizationCommand).build() {
+};
+__name(_DeleteCrossAccountAuthorizationCommand, "DeleteCrossAccountAuthorizationCommand");
+var DeleteCrossAccountAuthorizationCommand = _DeleteCrossAccountAuthorizationCommand;
+
+// src/commands/DeleteReadinessCheckCommand.ts
+
+
+
+
+var _DeleteReadinessCheckCommand = class _DeleteReadinessCheckCommand 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("Route53RecoveryReadiness", "DeleteReadinessCheck", {}).n("Route53RecoveryReadinessClient", "DeleteReadinessCheckCommand").f(void 0, void 0).ser(se_DeleteReadinessCheckCommand).de(de_DeleteReadinessCheckCommand).build() {
+};
+__name(_DeleteReadinessCheckCommand, "DeleteReadinessCheckCommand");
+var DeleteReadinessCheckCommand = _DeleteReadinessCheckCommand;
+
+// src/commands/DeleteRecoveryGroupCommand.ts
+
+
+
+
+var _DeleteRecoveryGroupCommand = class _DeleteRecoveryGroupCommand 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("Route53RecoveryReadiness", "DeleteRecoveryGroup", {}).n("Route53RecoveryReadinessClient", "DeleteRecoveryGroupCommand").f(void 0, void 0).ser(se_DeleteRecoveryGroupCommand).de(de_DeleteRecoveryGroupCommand).build() {
+};
+__name(_DeleteRecoveryGroupCommand, "DeleteRecoveryGroupCommand");
+var DeleteRecoveryGroupCommand = _DeleteRecoveryGroupCommand;
+
+// src/commands/DeleteResourceSetCommand.ts
+
+
+
+
+var _DeleteResourceSetCommand = class _DeleteResourceSetCommand 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("Route53RecoveryReadiness", "DeleteResourceSet", {}).n("Route53RecoveryReadinessClient", "DeleteResourceSetCommand").f(void 0, void 0).ser(se_DeleteResourceSetCommand).de(de_DeleteResourceSetCommand).build() {
+};
+__name(_DeleteResourceSetCommand, "DeleteResourceSetCommand");
+var DeleteResourceSetCommand = _DeleteResourceSetCommand;
+
+// src/commands/GetArchitectureRecommendationsCommand.ts
+
+
+
+
+var _GetArchitectureRecommendationsCommand = class _GetArchitectureRecommendationsCommand 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("Route53RecoveryReadiness", "GetArchitectureRecommendations", {}).n("Route53RecoveryReadinessClient", "GetArchitectureRecommendationsCommand").f(void 0, void 0).ser(se_GetArchitectureRecommendationsCommand).de(de_GetArchitectureRecommendationsCommand).build() {
+};
+__name(_GetArchitectureRecommendationsCommand, "GetArchitectureRecommendationsCommand");
+var GetArchitectureRecommendationsCommand = _GetArchitectureRecommendationsCommand;
+
+// src/commands/GetCellCommand.ts
+
+
+
+
+var _GetCellCommand = class _GetCellCommand 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("Route53RecoveryReadiness", "GetCell", {}).n("Route53RecoveryReadinessClient", "GetCellCommand").f(void 0, void 0).ser(se_GetCellCommand).de(de_GetCellCommand).build() {
+};
+__name(_GetCellCommand, "GetCellCommand");
+var GetCellCommand = _GetCellCommand;
+
+// src/commands/GetCellReadinessSummaryCommand.ts
+
+
+
+
+var _GetCellReadinessSummaryCommand = class _GetCellReadinessSummaryCommand 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("Route53RecoveryReadiness", "GetCellReadinessSummary", {}).n("Route53RecoveryReadinessClient", "GetCellReadinessSummaryCommand").f(void 0, void 0).ser(se_GetCellReadinessSummaryCommand).de(de_GetCellReadinessSummaryCommand).build() {
+};
+__name(_GetCellReadinessSummaryCommand, "GetCellReadinessSummaryCommand");
+var GetCellReadinessSummaryCommand = _GetCellReadinessSummaryCommand;
+
+// src/commands/GetReadinessCheckCommand.ts
+
+
+
+
+var _GetReadinessCheckCommand = class _GetReadinessCheckCommand 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("Route53RecoveryReadiness", "GetReadinessCheck", {}).n("Route53RecoveryReadinessClient", "GetReadinessCheckCommand").f(void 0, void 0).ser(se_GetReadinessCheckCommand).de(de_GetReadinessCheckCommand).build() {
+};
+__name(_GetReadinessCheckCommand, "GetReadinessCheckCommand");
+var GetReadinessCheckCommand = _GetReadinessCheckCommand;
+
+// src/commands/GetReadinessCheckResourceStatusCommand.ts
+
+
+
+
+var _GetReadinessCheckResourceStatusCommand = class _GetReadinessCheckResourceStatusCommand 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("Route53RecoveryReadiness", "GetReadinessCheckResourceStatus", {}).n("Route53RecoveryReadinessClient", "GetReadinessCheckResourceStatusCommand").f(void 0, void 0).ser(se_GetReadinessCheckResourceStatusCommand).de(de_GetReadinessCheckResourceStatusCommand).build() {
+};
+__name(_GetReadinessCheckResourceStatusCommand, "GetReadinessCheckResourceStatusCommand");
+var GetReadinessCheckResourceStatusCommand = _GetReadinessCheckResourceStatusCommand;
+
+// src/commands/GetReadinessCheckStatusCommand.ts
+
+
+
+
+var _GetReadinessCheckStatusCommand = class _GetReadinessCheckStatusCommand 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("Route53RecoveryReadiness", "GetReadinessCheckStatus", {}).n("Route53RecoveryReadinessClient", "GetReadinessCheckStatusCommand").f(void 0, void 0).ser(se_GetReadinessCheckStatusCommand).de(de_GetReadinessCheckStatusCommand).build() {
+};
+__name(_GetReadinessCheckStatusCommand, "GetReadinessCheckStatusCommand");
+var GetReadinessCheckStatusCommand = _GetReadinessCheckStatusCommand;
+
+// src/commands/GetRecoveryGroupCommand.ts
+
+
+
+
+var _GetRecoveryGroupCommand = class _GetRecoveryGroupCommand 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("Route53RecoveryReadiness", "GetRecoveryGroup", {}).n("Route53RecoveryReadinessClient", "GetRecoveryGroupCommand").f(void 0, void 0).ser(se_GetRecoveryGroupCommand).de(de_GetRecoveryGroupCommand).build() {
+};
+__name(_GetRecoveryGroupCommand, "GetRecoveryGroupCommand");
+var GetRecoveryGroupCommand = _GetRecoveryGroupCommand;
+
+// src/commands/GetRecoveryGroupReadinessSummaryCommand.ts
+
+
+
+
+var _GetRecoveryGroupReadinessSummaryCommand = class _GetRecoveryGroupReadinessSummaryCommand 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("Route53RecoveryReadiness", "GetRecoveryGroupReadinessSummary", {}).n("Route53RecoveryReadinessClient", "GetRecoveryGroupReadinessSummaryCommand").f(void 0, void 0).ser(se_GetRecoveryGroupReadinessSummaryCommand).de(de_GetRecoveryGroupReadinessSummaryCommand).build() {
+};
+__name(_GetRecoveryGroupReadinessSummaryCommand, "GetRecoveryGroupReadinessSummaryCommand");
+var GetRecoveryGroupReadinessSummaryCommand = _GetRecoveryGroupReadinessSummaryCommand;
+
+// src/commands/GetResourceSetCommand.ts
+
+
+
+
+var _GetResourceSetCommand = class _GetResourceSetCommand 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("Route53RecoveryReadiness", "GetResourceSet", {}).n("Route53RecoveryReadinessClient", "GetResourceSetCommand").f(void 0, void 0).ser(se_GetResourceSetCommand).de(de_GetResourceSetCommand).build() {
+};
+__name(_GetResourceSetCommand, "GetResourceSetCommand");
+var GetResourceSetCommand = _GetResourceSetCommand;
+
+// src/commands/ListCellsCommand.ts
+
+
+
+
+var _ListCellsCommand = class _ListCellsCommand 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("Route53RecoveryReadiness", "ListCells", {}).n("Route53RecoveryReadinessClient", "ListCellsCommand").f(void 0, void 0).ser(se_ListCellsCommand).de(de_ListCellsCommand).build() {
+};
+__name(_ListCellsCommand, "ListCellsCommand");
+var ListCellsCommand = _ListCellsCommand;
+
+// src/commands/ListCrossAccountAuthorizationsCommand.ts
+
+
+
+
+var _ListCrossAccountAuthorizationsCommand = class _ListCrossAccountAuthorizationsCommand 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("Route53RecoveryReadiness", "ListCrossAccountAuthorizations", {}).n("Route53RecoveryReadinessClient", "ListCrossAccountAuthorizationsCommand").f(void 0, void 0).ser(se_ListCrossAccountAuthorizationsCommand).de(de_ListCrossAccountAuthorizationsCommand).build() {
+};
+__name(_ListCrossAccountAuthorizationsCommand, "ListCrossAccountAuthorizationsCommand");
+var ListCrossAccountAuthorizationsCommand = _ListCrossAccountAuthorizationsCommand;
+
+// src/commands/ListReadinessChecksCommand.ts
+
+
+
+
+var _ListReadinessChecksCommand = class _ListReadinessChecksCommand 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("Route53RecoveryReadiness", "ListReadinessChecks", {}).n("Route53RecoveryReadinessClient", "ListReadinessChecksCommand").f(void 0, void 0).ser(se_ListReadinessChecksCommand).de(de_ListReadinessChecksCommand).build() {
+};
+__name(_ListReadinessChecksCommand, "ListReadinessChecksCommand");
+var ListReadinessChecksCommand = _ListReadinessChecksCommand;
+
+// src/commands/ListRecoveryGroupsCommand.ts
+
+
+
+
+var _ListRecoveryGroupsCommand = class _ListRecoveryGroupsCommand 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("Route53RecoveryReadiness", "ListRecoveryGroups", {}).n("Route53RecoveryReadinessClient", "ListRecoveryGroupsCommand").f(void 0, void 0).ser(se_ListRecoveryGroupsCommand).de(de_ListRecoveryGroupsCommand).build() {
+};
+__name(_ListRecoveryGroupsCommand, "ListRecoveryGroupsCommand");
+var ListRecoveryGroupsCommand = _ListRecoveryGroupsCommand;
+
+// src/commands/ListResourceSetsCommand.ts
+
+
+
+
+var _ListResourceSetsCommand = class _ListResourceSetsCommand 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("Route53RecoveryReadiness", "ListResourceSets", {}).n("Route53RecoveryReadinessClient", "ListResourceSetsCommand").f(void 0, void 0).ser(se_ListResourceSetsCommand).de(de_ListResourceSetsCommand).build() {
+};
+__name(_ListResourceSetsCommand, "ListResourceSetsCommand");
+var ListResourceSetsCommand = _ListResourceSetsCommand;
+
+// src/commands/ListRulesCommand.ts
+
+
+
+
+var _ListRulesCommand = class _ListRulesCommand 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("Route53RecoveryReadiness", "ListRules", {}).n("Route53RecoveryReadinessClient", "ListRulesCommand").f(void 0, void 0).ser(se_ListRulesCommand).de(de_ListRulesCommand).build() {
+};
+__name(_ListRulesCommand, "ListRulesCommand");
+var ListRulesCommand = _ListRulesCommand;
+
+// src/commands/ListTagsForResourcesCommand.ts
+
+
+
+
+var _ListTagsForResourcesCommand = class _ListTagsForResourcesCommand 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("Route53RecoveryReadiness", "ListTagsForResources", {}).n("Route53RecoveryReadinessClient", "ListTagsForResourcesCommand").f(void 0, void 0).ser(se_ListTagsForResourcesCommand).de(de_ListTagsForResourcesCommand).build() {
+};
+__name(_ListTagsForResourcesCommand, "ListTagsForResourcesCommand");
+var ListTagsForResourcesCommand = _ListTagsForResourcesCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Route53RecoveryReadiness", "TagResource", {}).n("Route53RecoveryReadinessClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("Route53RecoveryReadiness", "UntagResource", {}).n("Route53RecoveryReadinessClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateCellCommand.ts
+
+
+
+
+var _UpdateCellCommand = class _UpdateCellCommand 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("Route53RecoveryReadiness", "UpdateCell", {}).n("Route53RecoveryReadinessClient", "UpdateCellCommand").f(void 0, void 0).ser(se_UpdateCellCommand).de(de_UpdateCellCommand).build() {
+};
+__name(_UpdateCellCommand, "UpdateCellCommand");
+var UpdateCellCommand = _UpdateCellCommand;
+
+// src/commands/UpdateReadinessCheckCommand.ts
+
+
+
+
+var _UpdateReadinessCheckCommand = class _UpdateReadinessCheckCommand 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("Route53RecoveryReadiness", "UpdateReadinessCheck", {}).n("Route53RecoveryReadinessClient", "UpdateReadinessCheckCommand").f(void 0, void 0).ser(se_UpdateReadinessCheckCommand).de(de_UpdateReadinessCheckCommand).build() {
+};
+__name(_UpdateReadinessCheckCommand, "UpdateReadinessCheckCommand");
+var UpdateReadinessCheckCommand = _UpdateReadinessCheckCommand;
+
+// src/commands/UpdateRecoveryGroupCommand.ts
+
+
+
+
+var _UpdateRecoveryGroupCommand = class _UpdateRecoveryGroupCommand 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("Route53RecoveryReadiness", "UpdateRecoveryGroup", {}).n("Route53RecoveryReadinessClient", "UpdateRecoveryGroupCommand").f(void 0, void 0).ser(se_UpdateRecoveryGroupCommand).de(de_UpdateRecoveryGroupCommand).build() {
+};
+__name(_UpdateRecoveryGroupCommand, "UpdateRecoveryGroupCommand");
+var UpdateRecoveryGroupCommand = _UpdateRecoveryGroupCommand;
+
+// src/commands/UpdateResourceSetCommand.ts
+
+
+
+
+var _UpdateResourceSetCommand = class _UpdateResourceSetCommand 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("Route53RecoveryReadiness", "UpdateResourceSet", {}).n("Route53RecoveryReadinessClient", "UpdateResourceSetCommand").f(void 0, void 0).ser(se_UpdateResourceSetCommand).de(de_UpdateResourceSetCommand).build() {
+};
+__name(_UpdateResourceSetCommand, "UpdateResourceSetCommand");
+var UpdateResourceSetCommand = _UpdateResourceSetCommand;
+
+// src/Route53RecoveryReadiness.ts
+var commands = {
+  CreateCellCommand,
+  CreateCrossAccountAuthorizationCommand,
+  CreateReadinessCheckCommand,
+  CreateRecoveryGroupCommand,
+  CreateResourceSetCommand,
+  DeleteCellCommand,
+  DeleteCrossAccountAuthorizationCommand,
+  DeleteReadinessCheckCommand,
+  DeleteRecoveryGroupCommand,
+  DeleteResourceSetCommand,
+  GetArchitectureRecommendationsCommand,
+  GetCellCommand,
+  GetCellReadinessSummaryCommand,
+  GetReadinessCheckCommand,
+  GetReadinessCheckResourceStatusCommand,
+  GetReadinessCheckStatusCommand,
+  GetRecoveryGroupCommand,
+  GetRecoveryGroupReadinessSummaryCommand,
+  GetResourceSetCommand,
+  ListCellsCommand,
+  ListCrossAccountAuthorizationsCommand,
+  ListReadinessChecksCommand,
+  ListRecoveryGroupsCommand,
+  ListResourceSetsCommand,
+  ListRulesCommand,
+  ListTagsForResourcesCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateCellCommand,
+  UpdateReadinessCheckCommand,
+  UpdateRecoveryGroupCommand,
+  UpdateResourceSetCommand
+};
+var _Route53RecoveryReadiness = class _Route53RecoveryReadiness extends Route53RecoveryReadinessClient {
+};
+__name(_Route53RecoveryReadiness, "Route53RecoveryReadiness");
+var Route53RecoveryReadiness = _Route53RecoveryReadiness;
+(0, import_smithy_client.createAggregatedClient)(commands, Route53RecoveryReadiness);
+
+// src/pagination/GetCellReadinessSummaryPaginator.ts
+
+var paginateGetCellReadinessSummary = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, GetCellReadinessSummaryCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/GetReadinessCheckResourceStatusPaginator.ts
+
+var paginateGetReadinessCheckResourceStatus = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, GetReadinessCheckResourceStatusCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/GetReadinessCheckStatusPaginator.ts
+
+var paginateGetReadinessCheckStatus = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, GetReadinessCheckStatusCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/GetRecoveryGroupReadinessSummaryPaginator.ts
+
+var paginateGetRecoveryGroupReadinessSummary = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, GetRecoveryGroupReadinessSummaryCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListCellsPaginator.ts
+
+var paginateListCells = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, ListCellsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListCrossAccountAuthorizationsPaginator.ts
+
+var paginateListCrossAccountAuthorizations = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, ListCrossAccountAuthorizationsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListReadinessChecksPaginator.ts
+
+var paginateListReadinessChecks = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, ListReadinessChecksCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListRecoveryGroupsPaginator.ts
+
+var paginateListRecoveryGroups = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, ListRecoveryGroupsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListResourceSetsPaginator.ts
+
+var paginateListResourceSets = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, ListResourceSetsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListRulesPaginator.ts
+
+var paginateListRules = (0, import_core.createPaginator)(Route53RecoveryReadinessClient, ListRulesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  AccessDeniedException,
+  ConflictException,
+  CreateCellCommand,
+  CreateCrossAccountAuthorizationCommand,
+  CreateReadinessCheckCommand,
+  CreateRecoveryGroupCommand,
+  CreateResourceSetCommand,
+  DeleteCellCommand,
+  DeleteCrossAccountAuthorizationCommand,
+  DeleteReadinessCheckCommand,
+  DeleteRecoveryGroupCommand,
+  DeleteResourceSetCommand,
+  GetArchitectureRecommendationsCommand,
+  GetCellCommand,
+  GetCellReadinessSummaryCommand,
+  GetReadinessCheckCommand,
+  GetReadinessCheckResourceStatusCommand,
+  GetReadinessCheckStatusCommand,
+  GetRecoveryGroupCommand,
+  GetRecoveryGroupReadinessSummaryCommand,
+  GetResourceSetCommand,
+  InternalServerException,
+  ListCellsCommand,
+  ListCrossAccountAuthorizationsCommand,
+  ListReadinessChecksCommand,
+  ListRecoveryGroupsCommand,
+  ListResourceSetsCommand,
+  ListRulesCommand,
+  ListTagsForResourcesCommand,
+  Readiness,
+  ResourceNotFoundException,
+  Route53RecoveryReadiness,
+  Route53RecoveryReadinessClient,
+  Route53RecoveryReadinessServiceException,
+  TagResourceCommand,
+  ThrottlingException,
+  UntagResourceCommand,
+  UpdateCellCommand,
+  UpdateReadinessCheckCommand,
+  UpdateRecoveryGroupCommand,
+  UpdateResourceSetCommand,
+  ValidationException,
+  __Client,
+  paginateGetCellReadinessSummary,
+  paginateGetReadinessCheckResourceStatus,
+  paginateGetReadinessCheckStatus,
+  paginateGetRecoveryGroupReadinessSummary,
+  paginateListCells,
+  paginateListCrossAccountAuthorizations,
+  paginateListReadinessChecks,
+  paginateListRecoveryGroups,
+  paginateListResourceSets,
+  paginateListRules
+});
+