@aws-sdk/client-cloudhsm-v2 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,12 +1,1639 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloudHSMV2ServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./CloudHSMV2Client"), exports);
-tslib_1.__exportStar(require("./CloudHSMV2"), 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 CloudHSMV2ServiceException_1 = require("./models/CloudHSMV2ServiceException");
-Object.defineProperty(exports, "CloudHSMV2ServiceException", { enumerable: true, get: function () { return CloudHSMV2ServiceException_1.CloudHSMV2ServiceException; } });
+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, {
+  BackupPolicy: () => BackupPolicy,
+  BackupRetentionType: () => BackupRetentionType,
+  BackupState: () => BackupState,
+  CloudHSMV2: () => CloudHSMV2,
+  CloudHSMV2Client: () => CloudHSMV2Client,
+  CloudHSMV2ServiceException: () => CloudHSMV2ServiceException,
+  CloudHsmAccessDeniedException: () => CloudHsmAccessDeniedException,
+  CloudHsmInternalFailureException: () => CloudHsmInternalFailureException,
+  CloudHsmInvalidRequestException: () => CloudHsmInvalidRequestException,
+  CloudHsmResourceNotFoundException: () => CloudHsmResourceNotFoundException,
+  CloudHsmServiceException: () => CloudHsmServiceException,
+  CloudHsmTagException: () => CloudHsmTagException,
+  ClusterState: () => ClusterState,
+  CopyBackupToRegionCommand: () => CopyBackupToRegionCommand,
+  CreateClusterCommand: () => CreateClusterCommand,
+  CreateHsmCommand: () => CreateHsmCommand,
+  DeleteBackupCommand: () => DeleteBackupCommand,
+  DeleteClusterCommand: () => DeleteClusterCommand,
+  DeleteHsmCommand: () => DeleteHsmCommand,
+  DescribeBackupsCommand: () => DescribeBackupsCommand,
+  DescribeClustersCommand: () => DescribeClustersCommand,
+  HsmState: () => HsmState,
+  InitializeClusterCommand: () => InitializeClusterCommand,
+  ListTagsCommand: () => ListTagsCommand,
+  ModifyBackupAttributesCommand: () => ModifyBackupAttributesCommand,
+  ModifyClusterCommand: () => ModifyClusterCommand,
+  RestoreBackupCommand: () => RestoreBackupCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  UntagResourceCommand: () => UntagResourceCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeBackups: () => paginateDescribeBackups,
+  paginateDescribeClusters: () => paginateDescribeClusters,
+  paginateListTags: () => paginateListTags
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/CloudHSMV2Client.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: "cloudhsm"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/CloudHSMV2Client.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/CloudHSMV2Client.ts
+var _CloudHSMV2Client = class _CloudHSMV2Client 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(_CloudHSMV2Client, "CloudHSMV2Client");
+var CloudHSMV2Client = _CloudHSMV2Client;
+
+// src/CloudHSMV2.ts
+
+
+// src/commands/CopyBackupToRegionCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/CloudHSMV2ServiceException.ts
+
+var _CloudHSMV2ServiceException = class _CloudHSMV2ServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _CloudHSMV2ServiceException.prototype);
+  }
+};
+__name(_CloudHSMV2ServiceException, "CloudHSMV2ServiceException");
+var CloudHSMV2ServiceException = _CloudHSMV2ServiceException;
+
+// src/models/models_0.ts
+var BackupState = {
+  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
+  DELETED: "DELETED",
+  PENDING_DELETION: "PENDING_DELETION",
+  READY: "READY"
+};
+var BackupPolicy = {
+  DEFAULT: "DEFAULT"
+};
+var BackupRetentionType = {
+  DAYS: "DAYS"
+};
+var _CloudHsmAccessDeniedException = class _CloudHsmAccessDeniedException extends CloudHSMV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CloudHsmAccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CloudHsmAccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CloudHsmAccessDeniedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_CloudHsmAccessDeniedException, "CloudHsmAccessDeniedException");
+var CloudHsmAccessDeniedException = _CloudHsmAccessDeniedException;
+var _CloudHsmInternalFailureException = class _CloudHsmInternalFailureException extends CloudHSMV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CloudHsmInternalFailureException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "CloudHsmInternalFailureException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _CloudHsmInternalFailureException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_CloudHsmInternalFailureException, "CloudHsmInternalFailureException");
+var CloudHsmInternalFailureException = _CloudHsmInternalFailureException;
+var _CloudHsmInvalidRequestException = class _CloudHsmInvalidRequestException extends CloudHSMV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CloudHsmInvalidRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CloudHsmInvalidRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CloudHsmInvalidRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_CloudHsmInvalidRequestException, "CloudHsmInvalidRequestException");
+var CloudHsmInvalidRequestException = _CloudHsmInvalidRequestException;
+var _CloudHsmResourceNotFoundException = class _CloudHsmResourceNotFoundException extends CloudHSMV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CloudHsmResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CloudHsmResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CloudHsmResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_CloudHsmResourceNotFoundException, "CloudHsmResourceNotFoundException");
+var CloudHsmResourceNotFoundException = _CloudHsmResourceNotFoundException;
+var _CloudHsmServiceException = class _CloudHsmServiceException extends CloudHSMV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CloudHsmServiceException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CloudHsmServiceException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CloudHsmServiceException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_CloudHsmServiceException, "CloudHsmServiceException");
+var CloudHsmServiceException = _CloudHsmServiceException;
+var _CloudHsmTagException = class _CloudHsmTagException extends CloudHSMV2ServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CloudHsmTagException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CloudHsmTagException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CloudHsmTagException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_CloudHsmTagException, "CloudHsmTagException");
+var CloudHsmTagException = _CloudHsmTagException;
+var HsmState = {
+  ACTIVE: "ACTIVE",
+  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
+  DEGRADED: "DEGRADED",
+  DELETED: "DELETED",
+  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS"
+};
+var ClusterState = {
+  ACTIVE: "ACTIVE",
+  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
+  DEGRADED: "DEGRADED",
+  DELETED: "DELETED",
+  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+  INITIALIZED: "INITIALIZED",
+  INITIALIZE_IN_PROGRESS: "INITIALIZE_IN_PROGRESS",
+  UNINITIALIZED: "UNINITIALIZED",
+  UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS"
+};
+
+// src/protocols/Aws_json1_1.ts
+var se_CopyBackupToRegionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CopyBackupToRegion");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CopyBackupToRegionCommand");
+var se_CreateClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateClusterCommand");
+var se_CreateHsmCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateHsm");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateHsmCommand");
+var se_DeleteBackupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteBackup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteBackupCommand");
+var se_DeleteClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteClusterCommand");
+var se_DeleteHsmCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteHsm");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteHsmCommand");
+var se_DescribeBackupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeBackups");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeBackupsCommand");
+var se_DescribeClustersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeClusters");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeClustersCommand");
+var se_InitializeClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("InitializeCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_InitializeClusterCommand");
+var se_ListTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsCommand");
+var se_ModifyBackupAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ModifyBackupAttributes");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ModifyBackupAttributesCommand");
+var se_ModifyClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ModifyCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ModifyClusterCommand");
+var se_RestoreBackupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RestoreBackup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RestoreBackupCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var de_CopyBackupToRegionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CopyBackupToRegionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CopyBackupToRegionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CopyBackupToRegionCommand");
+var de_CopyBackupToRegionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    case "CloudHsmTagException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmTagException":
+      throw await de_CloudHsmTagExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CopyBackupToRegionCommandError");
+var de_CreateClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateClusterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateClusterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateClusterCommand");
+var de_CreateClusterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    case "CloudHsmTagException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmTagException":
+      throw await de_CloudHsmTagExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateClusterCommandError");
+var de_CreateHsmCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateHsmCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateHsmCommand");
+var de_CreateHsmCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateHsmCommandError");
+var de_DeleteBackupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteBackupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteBackupResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteBackupCommand");
+var de_DeleteBackupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteBackupCommandError");
+var de_DeleteClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteClusterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteClusterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteClusterCommand");
+var de_DeleteClusterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    case "CloudHsmTagException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmTagException":
+      throw await de_CloudHsmTagExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteClusterCommandError");
+var de_DeleteHsmCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteHsmCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteHsmCommand");
+var de_DeleteHsmCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteHsmCommandError");
+var de_DescribeBackupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeBackupsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeBackupsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeBackupsCommand");
+var de_DescribeBackupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    case "CloudHsmTagException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmTagException":
+      throw await de_CloudHsmTagExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeBackupsCommandError");
+var de_DescribeClustersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeClustersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeClustersResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeClustersCommand");
+var de_DescribeClustersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    case "CloudHsmTagException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmTagException":
+      throw await de_CloudHsmTagExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeClustersCommandError");
+var de_InitializeClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_InitializeClusterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_InitializeClusterCommand");
+var de_InitializeClusterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_InitializeClusterCommandError");
+var de_ListTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsCommand");
+var de_ListTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    case "CloudHsmTagException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmTagException":
+      throw await de_CloudHsmTagExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsCommandError");
+var de_ModifyBackupAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ModifyBackupAttributesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ModifyBackupAttributesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ModifyBackupAttributesCommand");
+var de_ModifyBackupAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ModifyBackupAttributesCommandError");
+var de_ModifyClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ModifyClusterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ModifyClusterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ModifyClusterCommand");
+var de_ModifyClusterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ModifyClusterCommandError");
+var de_RestoreBackupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RestoreBackupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_RestoreBackupResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RestoreBackupCommand");
+var de_RestoreBackupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RestoreBackupCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    case "CloudHsmTagException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmTagException":
+      throw await de_CloudHsmTagExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CloudHsmAccessDeniedException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmAccessDeniedException":
+      throw await de_CloudHsmAccessDeniedExceptionRes(parsedOutput, context);
+    case "CloudHsmInternalFailureException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInternalFailureException":
+      throw await de_CloudHsmInternalFailureExceptionRes(parsedOutput, context);
+    case "CloudHsmInvalidRequestException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmInvalidRequestException":
+      throw await de_CloudHsmInvalidRequestExceptionRes(parsedOutput, context);
+    case "CloudHsmResourceNotFoundException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmResourceNotFoundException":
+      throw await de_CloudHsmResourceNotFoundExceptionRes(parsedOutput, context);
+    case "CloudHsmServiceException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmServiceException":
+      throw await de_CloudHsmServiceExceptionRes(parsedOutput, context);
+    case "CloudHsmTagException":
+    case "com.amazonaws.cloudhsmv2#CloudHsmTagException":
+      throw await de_CloudHsmTagExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_CloudHsmAccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CloudHsmAccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CloudHsmAccessDeniedExceptionRes");
+var de_CloudHsmInternalFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CloudHsmInternalFailureException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CloudHsmInternalFailureExceptionRes");
+var de_CloudHsmInvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CloudHsmInvalidRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CloudHsmInvalidRequestExceptionRes");
+var de_CloudHsmResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CloudHsmResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CloudHsmResourceNotFoundExceptionRes");
+var de_CloudHsmServiceExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CloudHsmServiceException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CloudHsmServiceExceptionRes");
+var de_CloudHsmTagExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CloudHsmTagException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CloudHsmTagExceptionRes");
+var de_Backup = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BackupId: import_smithy_client.expectString,
+    BackupState: import_smithy_client.expectString,
+    ClusterId: import_smithy_client.expectString,
+    CopyTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreateTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DeleteTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NeverExpires: import_smithy_client.expectBoolean,
+    SourceBackup: import_smithy_client.expectString,
+    SourceCluster: import_smithy_client.expectString,
+    SourceRegion: import_smithy_client.expectString,
+    TagList: import_smithy_client._json
+  });
+}, "de_Backup");
+var de_Backups = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Backup(entry, context);
+  });
+  return retVal;
+}, "de_Backups");
+var de_Cluster = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BackupPolicy: import_smithy_client.expectString,
+    BackupRetentionPolicy: import_smithy_client._json,
+    Certificates: import_smithy_client._json,
+    ClusterId: import_smithy_client.expectString,
+    CreateTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    HsmType: import_smithy_client.expectString,
+    Hsms: import_smithy_client._json,
+    PreCoPassword: import_smithy_client.expectString,
+    SecurityGroup: import_smithy_client.expectString,
+    SourceBackupId: import_smithy_client.expectString,
+    State: import_smithy_client.expectString,
+    StateMessage: import_smithy_client.expectString,
+    SubnetMapping: import_smithy_client._json,
+    TagList: import_smithy_client._json,
+    VpcId: import_smithy_client.expectString
+  });
+}, "de_Cluster");
+var de_Clusters = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Cluster(entry, context);
+  });
+  return retVal;
+}, "de_Clusters");
+var de_CopyBackupToRegionResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DestinationBackup: (_) => de_DestinationBackup(_, context)
+  });
+}, "de_CopyBackupToRegionResponse");
+var de_CreateClusterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cluster: (_) => de_Cluster(_, context)
+  });
+}, "de_CreateClusterResponse");
+var de_DeleteBackupResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Backup: (_) => de_Backup(_, context)
+  });
+}, "de_DeleteBackupResponse");
+var de_DeleteClusterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cluster: (_) => de_Cluster(_, context)
+  });
+}, "de_DeleteClusterResponse");
+var de_DescribeBackupsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Backups: (_) => de_Backups(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_DescribeBackupsResponse");
+var de_DescribeClustersResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Clusters: (_) => de_Clusters(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_DescribeClustersResponse");
+var de_DestinationBackup = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreateTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    SourceBackup: import_smithy_client.expectString,
+    SourceCluster: import_smithy_client.expectString,
+    SourceRegion: import_smithy_client.expectString
+  });
+}, "de_DestinationBackup");
+var de_ModifyBackupAttributesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Backup: (_) => de_Backup(_, context)
+  });
+}, "de_ModifyBackupAttributesResponse");
+var de_ModifyClusterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cluster: (_) => de_Cluster(_, context)
+  });
+}, "de_ModifyClusterResponse");
+var de_RestoreBackupResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Backup: (_) => de_Backup(_, context)
+  });
+}, "de_RestoreBackupResponse");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(CloudHSMV2ServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `BaldrApiService.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CopyBackupToRegionCommand.ts
+var _CopyBackupToRegionCommand = class _CopyBackupToRegionCommand 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("BaldrApiService", "CopyBackupToRegion", {}).n("CloudHSMV2Client", "CopyBackupToRegionCommand").f(void 0, void 0).ser(se_CopyBackupToRegionCommand).de(de_CopyBackupToRegionCommand).build() {
+};
+__name(_CopyBackupToRegionCommand, "CopyBackupToRegionCommand");
+var CopyBackupToRegionCommand = _CopyBackupToRegionCommand;
+
+// src/commands/CreateClusterCommand.ts
+
+
+
+
+var _CreateClusterCommand = class _CreateClusterCommand 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("BaldrApiService", "CreateCluster", {}).n("CloudHSMV2Client", "CreateClusterCommand").f(void 0, void 0).ser(se_CreateClusterCommand).de(de_CreateClusterCommand).build() {
+};
+__name(_CreateClusterCommand, "CreateClusterCommand");
+var CreateClusterCommand = _CreateClusterCommand;
+
+// src/commands/CreateHsmCommand.ts
+
+
+
+
+var _CreateHsmCommand = class _CreateHsmCommand 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("BaldrApiService", "CreateHsm", {}).n("CloudHSMV2Client", "CreateHsmCommand").f(void 0, void 0).ser(se_CreateHsmCommand).de(de_CreateHsmCommand).build() {
+};
+__name(_CreateHsmCommand, "CreateHsmCommand");
+var CreateHsmCommand = _CreateHsmCommand;
+
+// src/commands/DeleteBackupCommand.ts
+
+
+
+
+var _DeleteBackupCommand = class _DeleteBackupCommand 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("BaldrApiService", "DeleteBackup", {}).n("CloudHSMV2Client", "DeleteBackupCommand").f(void 0, void 0).ser(se_DeleteBackupCommand).de(de_DeleteBackupCommand).build() {
+};
+__name(_DeleteBackupCommand, "DeleteBackupCommand");
+var DeleteBackupCommand = _DeleteBackupCommand;
+
+// src/commands/DeleteClusterCommand.ts
+
+
+
+
+var _DeleteClusterCommand = class _DeleteClusterCommand 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("BaldrApiService", "DeleteCluster", {}).n("CloudHSMV2Client", "DeleteClusterCommand").f(void 0, void 0).ser(se_DeleteClusterCommand).de(de_DeleteClusterCommand).build() {
+};
+__name(_DeleteClusterCommand, "DeleteClusterCommand");
+var DeleteClusterCommand = _DeleteClusterCommand;
+
+// src/commands/DeleteHsmCommand.ts
+
+
+
+
+var _DeleteHsmCommand = class _DeleteHsmCommand 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("BaldrApiService", "DeleteHsm", {}).n("CloudHSMV2Client", "DeleteHsmCommand").f(void 0, void 0).ser(se_DeleteHsmCommand).de(de_DeleteHsmCommand).build() {
+};
+__name(_DeleteHsmCommand, "DeleteHsmCommand");
+var DeleteHsmCommand = _DeleteHsmCommand;
+
+// src/commands/DescribeBackupsCommand.ts
+
+
+
+
+var _DescribeBackupsCommand = class _DescribeBackupsCommand 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("BaldrApiService", "DescribeBackups", {}).n("CloudHSMV2Client", "DescribeBackupsCommand").f(void 0, void 0).ser(se_DescribeBackupsCommand).de(de_DescribeBackupsCommand).build() {
+};
+__name(_DescribeBackupsCommand, "DescribeBackupsCommand");
+var DescribeBackupsCommand = _DescribeBackupsCommand;
+
+// src/commands/DescribeClustersCommand.ts
+
+
+
+
+var _DescribeClustersCommand = class _DescribeClustersCommand 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("BaldrApiService", "DescribeClusters", {}).n("CloudHSMV2Client", "DescribeClustersCommand").f(void 0, void 0).ser(se_DescribeClustersCommand).de(de_DescribeClustersCommand).build() {
+};
+__name(_DescribeClustersCommand, "DescribeClustersCommand");
+var DescribeClustersCommand = _DescribeClustersCommand;
+
+// src/commands/InitializeClusterCommand.ts
+
+
+
+
+var _InitializeClusterCommand = class _InitializeClusterCommand 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("BaldrApiService", "InitializeCluster", {}).n("CloudHSMV2Client", "InitializeClusterCommand").f(void 0, void 0).ser(se_InitializeClusterCommand).de(de_InitializeClusterCommand).build() {
+};
+__name(_InitializeClusterCommand, "InitializeClusterCommand");
+var InitializeClusterCommand = _InitializeClusterCommand;
+
+// src/commands/ListTagsCommand.ts
+
+
+
+
+var _ListTagsCommand = class _ListTagsCommand 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("BaldrApiService", "ListTags", {}).n("CloudHSMV2Client", "ListTagsCommand").f(void 0, void 0).ser(se_ListTagsCommand).de(de_ListTagsCommand).build() {
+};
+__name(_ListTagsCommand, "ListTagsCommand");
+var ListTagsCommand = _ListTagsCommand;
+
+// src/commands/ModifyBackupAttributesCommand.ts
+
+
+
+
+var _ModifyBackupAttributesCommand = class _ModifyBackupAttributesCommand 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("BaldrApiService", "ModifyBackupAttributes", {}).n("CloudHSMV2Client", "ModifyBackupAttributesCommand").f(void 0, void 0).ser(se_ModifyBackupAttributesCommand).de(de_ModifyBackupAttributesCommand).build() {
+};
+__name(_ModifyBackupAttributesCommand, "ModifyBackupAttributesCommand");
+var ModifyBackupAttributesCommand = _ModifyBackupAttributesCommand;
+
+// src/commands/ModifyClusterCommand.ts
+
+
+
+
+var _ModifyClusterCommand = class _ModifyClusterCommand 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("BaldrApiService", "ModifyCluster", {}).n("CloudHSMV2Client", "ModifyClusterCommand").f(void 0, void 0).ser(se_ModifyClusterCommand).de(de_ModifyClusterCommand).build() {
+};
+__name(_ModifyClusterCommand, "ModifyClusterCommand");
+var ModifyClusterCommand = _ModifyClusterCommand;
+
+// src/commands/RestoreBackupCommand.ts
+
+
+
+
+var _RestoreBackupCommand = class _RestoreBackupCommand 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("BaldrApiService", "RestoreBackup", {}).n("CloudHSMV2Client", "RestoreBackupCommand").f(void 0, void 0).ser(se_RestoreBackupCommand).de(de_RestoreBackupCommand).build() {
+};
+__name(_RestoreBackupCommand, "RestoreBackupCommand");
+var RestoreBackupCommand = _RestoreBackupCommand;
+
+// 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("BaldrApiService", "TagResource", {}).n("CloudHSMV2Client", "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("BaldrApiService", "UntagResource", {}).n("CloudHSMV2Client", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/CloudHSMV2.ts
+var commands = {
+  CopyBackupToRegionCommand,
+  CreateClusterCommand,
+  CreateHsmCommand,
+  DeleteBackupCommand,
+  DeleteClusterCommand,
+  DeleteHsmCommand,
+  DescribeBackupsCommand,
+  DescribeClustersCommand,
+  InitializeClusterCommand,
+  ListTagsCommand,
+  ModifyBackupAttributesCommand,
+  ModifyClusterCommand,
+  RestoreBackupCommand,
+  TagResourceCommand,
+  UntagResourceCommand
+};
+var _CloudHSMV2 = class _CloudHSMV2 extends CloudHSMV2Client {
+};
+__name(_CloudHSMV2, "CloudHSMV2");
+var CloudHSMV2 = _CloudHSMV2;
+(0, import_smithy_client.createAggregatedClient)(commands, CloudHSMV2);
+
+// src/pagination/DescribeBackupsPaginator.ts
+var import_core = require("@smithy/core");
+var paginateDescribeBackups = (0, import_core.createPaginator)(CloudHSMV2Client, DescribeBackupsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/DescribeClustersPaginator.ts
+
+var paginateDescribeClusters = (0, import_core.createPaginator)(CloudHSMV2Client, DescribeClustersCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListTagsPaginator.ts
+
+var paginateListTags = (0, import_core.createPaginator)(CloudHSMV2Client, ListTagsCommand, "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 = {
+  BackupPolicy,
+  BackupRetentionType,
+  BackupState,
+  CloudHSMV2,
+  CloudHSMV2Client,
+  CloudHSMV2ServiceException,
+  CloudHsmAccessDeniedException,
+  CloudHsmInternalFailureException,
+  CloudHsmInvalidRequestException,
+  CloudHsmResourceNotFoundException,
+  CloudHsmServiceException,
+  CloudHsmTagException,
+  ClusterState,
+  CopyBackupToRegionCommand,
+  CreateClusterCommand,
+  CreateHsmCommand,
+  DeleteBackupCommand,
+  DeleteClusterCommand,
+  DeleteHsmCommand,
+  DescribeBackupsCommand,
+  DescribeClustersCommand,
+  HsmState,
+  InitializeClusterCommand,
+  ListTagsCommand,
+  ModifyBackupAttributesCommand,
+  ModifyClusterCommand,
+  RestoreBackupCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  __Client,
+  paginateDescribeBackups,
+  paginateDescribeClusters,
+  paginateListTags
+});
+