@aws-sdk/client-acm-pca 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,13 +1,2666 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ACMPCAServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ACMPCAClient"), exports);
-tslib_1.__exportStar(require("./ACMPCA"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var ACMPCAServiceException_1 = require("./models/ACMPCAServiceException");
-Object.defineProperty(exports, "ACMPCAServiceException", { enumerable: true, get: function () { return ACMPCAServiceException_1.ACMPCAServiceException; } });
+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, {
+  ACMPCA: () => ACMPCA,
+  ACMPCAClient: () => ACMPCAClient,
+  ACMPCAServiceException: () => ACMPCAServiceException,
+  AccessMethodType: () => AccessMethodType,
+  ActionType: () => ActionType,
+  AuditReportResponseFormat: () => AuditReportResponseFormat,
+  AuditReportStatus: () => AuditReportStatus,
+  CertificateAuthorityStatus: () => CertificateAuthorityStatus,
+  CertificateAuthorityType: () => CertificateAuthorityType,
+  CertificateAuthorityUsageMode: () => CertificateAuthorityUsageMode,
+  CertificateMismatchException: () => CertificateMismatchException,
+  ConcurrentModificationException: () => ConcurrentModificationException,
+  CreateCertificateAuthorityAuditReportCommand: () => CreateCertificateAuthorityAuditReportCommand,
+  CreateCertificateAuthorityCommand: () => CreateCertificateAuthorityCommand,
+  CreatePermissionCommand: () => CreatePermissionCommand,
+  DeleteCertificateAuthorityCommand: () => DeleteCertificateAuthorityCommand,
+  DeletePermissionCommand: () => DeletePermissionCommand,
+  DeletePolicyCommand: () => DeletePolicyCommand,
+  DescribeCertificateAuthorityAuditReportCommand: () => DescribeCertificateAuthorityAuditReportCommand,
+  DescribeCertificateAuthorityCommand: () => DescribeCertificateAuthorityCommand,
+  ExtendedKeyUsageType: () => ExtendedKeyUsageType,
+  FailureReason: () => FailureReason,
+  GetCertificateAuthorityCertificateCommand: () => GetCertificateAuthorityCertificateCommand,
+  GetCertificateAuthorityCsrCommand: () => GetCertificateAuthorityCsrCommand,
+  GetCertificateCommand: () => GetCertificateCommand,
+  GetPolicyCommand: () => GetPolicyCommand,
+  ImportCertificateAuthorityCertificateCommand: () => ImportCertificateAuthorityCertificateCommand,
+  InvalidArgsException: () => InvalidArgsException,
+  InvalidArnException: () => InvalidArnException,
+  InvalidNextTokenException: () => InvalidNextTokenException,
+  InvalidPolicyException: () => InvalidPolicyException,
+  InvalidRequestException: () => InvalidRequestException,
+  InvalidStateException: () => InvalidStateException,
+  InvalidTagException: () => InvalidTagException,
+  IssueCertificateCommand: () => IssueCertificateCommand,
+  KeyAlgorithm: () => KeyAlgorithm,
+  KeyStorageSecurityStandard: () => KeyStorageSecurityStandard,
+  LimitExceededException: () => LimitExceededException,
+  ListCertificateAuthoritiesCommand: () => ListCertificateAuthoritiesCommand,
+  ListPermissionsCommand: () => ListPermissionsCommand,
+  ListTagsCommand: () => ListTagsCommand,
+  LockoutPreventedException: () => LockoutPreventedException,
+  MalformedCSRException: () => MalformedCSRException,
+  MalformedCertificateException: () => MalformedCertificateException,
+  PermissionAlreadyExistsException: () => PermissionAlreadyExistsException,
+  PolicyQualifierId: () => PolicyQualifierId,
+  PutPolicyCommand: () => PutPolicyCommand,
+  RequestAlreadyProcessedException: () => RequestAlreadyProcessedException,
+  RequestFailedException: () => RequestFailedException,
+  RequestInProgressException: () => RequestInProgressException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResourceOwner: () => ResourceOwner,
+  RestoreCertificateAuthorityCommand: () => RestoreCertificateAuthorityCommand,
+  RevocationReason: () => RevocationReason,
+  RevokeCertificateCommand: () => RevokeCertificateCommand,
+  S3ObjectAcl: () => S3ObjectAcl,
+  SigningAlgorithm: () => SigningAlgorithm,
+  TagCertificateAuthorityCommand: () => TagCertificateAuthorityCommand,
+  TooManyTagsException: () => TooManyTagsException,
+  UntagCertificateAuthorityCommand: () => UntagCertificateAuthorityCommand,
+  UpdateCertificateAuthorityCommand: () => UpdateCertificateAuthorityCommand,
+  ValidityPeriodType: () => ValidityPeriodType,
+  __Client: () => import_smithy_client.Client,
+  paginateListCertificateAuthorities: () => paginateListCertificateAuthorities,
+  paginateListPermissions: () => paginateListPermissions,
+  paginateListTags: () => paginateListTags,
+  waitForAuditReportCreated: () => waitForAuditReportCreated,
+  waitForCertificateAuthorityCSRCreated: () => waitForCertificateAuthorityCSRCreated,
+  waitForCertificateIssued: () => waitForCertificateIssued,
+  waitUntilAuditReportCreated: () => waitUntilAuditReportCreated,
+  waitUntilCertificateAuthorityCSRCreated: () => waitUntilCertificateAuthorityCSRCreated,
+  waitUntilCertificateIssued: () => waitUntilCertificateIssued
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ACMPCAClient.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: "acm-pca"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ACMPCAClient.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/ACMPCAClient.ts
+var _ACMPCAClient = class _ACMPCAClient 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(_ACMPCAClient, "ACMPCAClient");
+var ACMPCAClient = _ACMPCAClient;
+
+// src/ACMPCA.ts
+
+
+// src/commands/CreateCertificateAuthorityAuditReportCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/ACMPCAServiceException.ts
+
+var _ACMPCAServiceException = class _ACMPCAServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ACMPCAServiceException.prototype);
+  }
+};
+__name(_ACMPCAServiceException, "ACMPCAServiceException");
+var ACMPCAServiceException = _ACMPCAServiceException;
+
+// src/models/models_0.ts
+var AccessMethodType = {
+  CA_REPOSITORY: "CA_REPOSITORY",
+  RESOURCE_PKI_MANIFEST: "RESOURCE_PKI_MANIFEST",
+  RESOURCE_PKI_NOTIFY: "RESOURCE_PKI_NOTIFY"
+};
+var KeyAlgorithm = {
+  EC_prime256v1: "EC_prime256v1",
+  EC_secp384r1: "EC_secp384r1",
+  RSA_2048: "RSA_2048",
+  RSA_4096: "RSA_4096"
+};
+var SigningAlgorithm = {
+  SHA256WITHECDSA: "SHA256WITHECDSA",
+  SHA256WITHRSA: "SHA256WITHRSA",
+  SHA384WITHECDSA: "SHA384WITHECDSA",
+  SHA384WITHRSA: "SHA384WITHRSA",
+  SHA512WITHECDSA: "SHA512WITHECDSA",
+  SHA512WITHRSA: "SHA512WITHRSA"
+};
+var CertificateAuthorityType = {
+  ROOT: "ROOT",
+  SUBORDINATE: "SUBORDINATE"
+};
+var KeyStorageSecurityStandard = {
+  FIPS_140_2_LEVEL_2_OR_HIGHER: "FIPS_140_2_LEVEL_2_OR_HIGHER",
+  FIPS_140_2_LEVEL_3_OR_HIGHER: "FIPS_140_2_LEVEL_3_OR_HIGHER"
+};
+var S3ObjectAcl = {
+  BUCKET_OWNER_FULL_CONTROL: "BUCKET_OWNER_FULL_CONTROL",
+  PUBLIC_READ: "PUBLIC_READ"
+};
+var CertificateAuthorityUsageMode = {
+  GENERAL_PURPOSE: "GENERAL_PURPOSE",
+  SHORT_LIVED_CERTIFICATE: "SHORT_LIVED_CERTIFICATE"
+};
+var _InvalidArgsException = class _InvalidArgsException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidArgsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidArgsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidArgsException.prototype);
+  }
+};
+__name(_InvalidArgsException, "InvalidArgsException");
+var InvalidArgsException = _InvalidArgsException;
+var _InvalidPolicyException = class _InvalidPolicyException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidPolicyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidPolicyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidPolicyException.prototype);
+  }
+};
+__name(_InvalidPolicyException, "InvalidPolicyException");
+var InvalidPolicyException = _InvalidPolicyException;
+var _InvalidTagException = class _InvalidTagException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidTagException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidTagException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidTagException.prototype);
+  }
+};
+__name(_InvalidTagException, "InvalidTagException");
+var InvalidTagException = _InvalidTagException;
+var _LimitExceededException = class _LimitExceededException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var AuditReportResponseFormat = {
+  CSV: "CSV",
+  JSON: "JSON"
+};
+var _InvalidArnException = class _InvalidArnException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidArnException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidArnException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidArnException.prototype);
+  }
+};
+__name(_InvalidArnException, "InvalidArnException");
+var InvalidArnException = _InvalidArnException;
+var _InvalidStateException = class _InvalidStateException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidStateException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidStateException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidStateException.prototype);
+  }
+};
+__name(_InvalidStateException, "InvalidStateException");
+var InvalidStateException = _InvalidStateException;
+var _RequestFailedException = class _RequestFailedException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RequestFailedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RequestFailedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RequestFailedException.prototype);
+  }
+};
+__name(_RequestFailedException, "RequestFailedException");
+var RequestFailedException = _RequestFailedException;
+var _RequestInProgressException = class _RequestInProgressException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RequestInProgressException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RequestInProgressException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RequestInProgressException.prototype);
+  }
+};
+__name(_RequestInProgressException, "RequestInProgressException");
+var RequestInProgressException = _RequestInProgressException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var ActionType = {
+  GetCertificate: "GetCertificate",
+  IssueCertificate: "IssueCertificate",
+  ListPermissions: "ListPermissions"
+};
+var _PermissionAlreadyExistsException = class _PermissionAlreadyExistsException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PermissionAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PermissionAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PermissionAlreadyExistsException.prototype);
+  }
+};
+__name(_PermissionAlreadyExistsException, "PermissionAlreadyExistsException");
+var PermissionAlreadyExistsException = _PermissionAlreadyExistsException;
+var _ConcurrentModificationException = class _ConcurrentModificationException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConcurrentModificationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConcurrentModificationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);
+  }
+};
+__name(_ConcurrentModificationException, "ConcurrentModificationException");
+var ConcurrentModificationException = _ConcurrentModificationException;
+var _LockoutPreventedException = class _LockoutPreventedException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LockoutPreventedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LockoutPreventedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LockoutPreventedException.prototype);
+  }
+};
+__name(_LockoutPreventedException, "LockoutPreventedException");
+var LockoutPreventedException = _LockoutPreventedException;
+var FailureReason = {
+  OTHER: "OTHER",
+  REQUEST_TIMED_OUT: "REQUEST_TIMED_OUT",
+  UNSUPPORTED_ALGORITHM: "UNSUPPORTED_ALGORITHM"
+};
+var CertificateAuthorityStatus = {
+  ACTIVE: "ACTIVE",
+  CREATING: "CREATING",
+  DELETED: "DELETED",
+  DISABLED: "DISABLED",
+  EXPIRED: "EXPIRED",
+  FAILED: "FAILED",
+  PENDING_CERTIFICATE: "PENDING_CERTIFICATE"
+};
+var AuditReportStatus = {
+  CREATING: "CREATING",
+  FAILED: "FAILED",
+  SUCCESS: "SUCCESS"
+};
+var _CertificateMismatchException = class _CertificateMismatchException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CertificateMismatchException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CertificateMismatchException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CertificateMismatchException.prototype);
+  }
+};
+__name(_CertificateMismatchException, "CertificateMismatchException");
+var CertificateMismatchException = _CertificateMismatchException;
+var _InvalidRequestException = class _InvalidRequestException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidRequestException.prototype);
+  }
+};
+__name(_InvalidRequestException, "InvalidRequestException");
+var InvalidRequestException = _InvalidRequestException;
+var _MalformedCertificateException = class _MalformedCertificateException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MalformedCertificateException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MalformedCertificateException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MalformedCertificateException.prototype);
+  }
+};
+__name(_MalformedCertificateException, "MalformedCertificateException");
+var MalformedCertificateException = _MalformedCertificateException;
+var PolicyQualifierId = {
+  CPS: "CPS"
+};
+var ExtendedKeyUsageType = {
+  CERTIFICATE_TRANSPARENCY: "CERTIFICATE_TRANSPARENCY",
+  CLIENT_AUTH: "CLIENT_AUTH",
+  CODE_SIGNING: "CODE_SIGNING",
+  DOCUMENT_SIGNING: "DOCUMENT_SIGNING",
+  EMAIL_PROTECTION: "EMAIL_PROTECTION",
+  OCSP_SIGNING: "OCSP_SIGNING",
+  SERVER_AUTH: "SERVER_AUTH",
+  SMART_CARD_LOGIN: "SMART_CARD_LOGIN",
+  TIME_STAMPING: "TIME_STAMPING"
+};
+var ValidityPeriodType = {
+  ABSOLUTE: "ABSOLUTE",
+  DAYS: "DAYS",
+  END_DATE: "END_DATE",
+  MONTHS: "MONTHS",
+  YEARS: "YEARS"
+};
+var _MalformedCSRException = class _MalformedCSRException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MalformedCSRException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MalformedCSRException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MalformedCSRException.prototype);
+  }
+};
+__name(_MalformedCSRException, "MalformedCSRException");
+var MalformedCSRException = _MalformedCSRException;
+var _InvalidNextTokenException = class _InvalidNextTokenException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidNextTokenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidNextTokenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidNextTokenException.prototype);
+  }
+};
+__name(_InvalidNextTokenException, "InvalidNextTokenException");
+var InvalidNextTokenException = _InvalidNextTokenException;
+var ResourceOwner = {
+  OTHER_ACCOUNTS: "OTHER_ACCOUNTS",
+  SELF: "SELF"
+};
+var _RequestAlreadyProcessedException = class _RequestAlreadyProcessedException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RequestAlreadyProcessedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RequestAlreadyProcessedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RequestAlreadyProcessedException.prototype);
+  }
+};
+__name(_RequestAlreadyProcessedException, "RequestAlreadyProcessedException");
+var RequestAlreadyProcessedException = _RequestAlreadyProcessedException;
+var RevocationReason = {
+  AFFILIATION_CHANGED: "AFFILIATION_CHANGED",
+  A_A_COMPROMISE: "A_A_COMPROMISE",
+  CERTIFICATE_AUTHORITY_COMPROMISE: "CERTIFICATE_AUTHORITY_COMPROMISE",
+  CESSATION_OF_OPERATION: "CESSATION_OF_OPERATION",
+  KEY_COMPROMISE: "KEY_COMPROMISE",
+  PRIVILEGE_WITHDRAWN: "PRIVILEGE_WITHDRAWN",
+  SUPERSEDED: "SUPERSEDED",
+  UNSPECIFIED: "UNSPECIFIED"
+};
+var _TooManyTagsException = class _TooManyTagsException extends ACMPCAServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+
+// src/protocols/Aws_json1_1.ts
+var se_CreateCertificateAuthorityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateCertificateAuthority");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateCertificateAuthorityCommand");
+var se_CreateCertificateAuthorityAuditReportCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateCertificateAuthorityAuditReport");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateCertificateAuthorityAuditReportCommand");
+var se_CreatePermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreatePermission");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreatePermissionCommand");
+var se_DeleteCertificateAuthorityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteCertificateAuthority");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteCertificateAuthorityCommand");
+var se_DeletePermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeletePermission");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeletePermissionCommand");
+var se_DeletePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeletePolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeletePolicyCommand");
+var se_DescribeCertificateAuthorityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCertificateAuthority");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCertificateAuthorityCommand");
+var se_DescribeCertificateAuthorityAuditReportCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCertificateAuthorityAuditReport");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCertificateAuthorityAuditReportCommand");
+var se_GetCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetCertificateCommand");
+var se_GetCertificateAuthorityCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetCertificateAuthorityCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetCertificateAuthorityCertificateCommand");
+var se_GetCertificateAuthorityCsrCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetCertificateAuthorityCsr");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetCertificateAuthorityCsrCommand");
+var se_GetPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetPolicyCommand");
+var se_ImportCertificateAuthorityCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ImportCertificateAuthorityCertificate");
+  let body;
+  body = JSON.stringify(se_ImportCertificateAuthorityCertificateRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ImportCertificateAuthorityCertificateCommand");
+var se_IssueCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("IssueCertificate");
+  let body;
+  body = JSON.stringify(se_IssueCertificateRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_IssueCertificateCommand");
+var se_ListCertificateAuthoritiesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListCertificateAuthorities");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListCertificateAuthoritiesCommand");
+var se_ListPermissionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListPermissions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListPermissionsCommand");
+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_PutPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutPolicyCommand");
+var se_RestoreCertificateAuthorityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RestoreCertificateAuthority");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RestoreCertificateAuthorityCommand");
+var se_RevokeCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RevokeCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RevokeCertificateCommand");
+var se_TagCertificateAuthorityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagCertificateAuthority");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagCertificateAuthorityCommand");
+var se_UntagCertificateAuthorityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagCertificateAuthority");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagCertificateAuthorityCommand");
+var se_UpdateCertificateAuthorityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateCertificateAuthority");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateCertificateAuthorityCommand");
+var de_CreateCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateCertificateAuthorityCommandError(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_CreateCertificateAuthorityCommand");
+var de_CreateCertificateAuthorityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArgsException":
+    case "com.amazonaws.acmpca#InvalidArgsException":
+      throw await de_InvalidArgsExceptionRes(parsedOutput, context);
+    case "InvalidPolicyException":
+    case "com.amazonaws.acmpca#InvalidPolicyException":
+      throw await de_InvalidPolicyExceptionRes(parsedOutput, context);
+    case "InvalidTagException":
+    case "com.amazonaws.acmpca#InvalidTagException":
+      throw await de_InvalidTagExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.acmpca#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCertificateAuthorityCommandError");
+var de_CreateCertificateAuthorityAuditReportCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateCertificateAuthorityAuditReportCommandError(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_CreateCertificateAuthorityAuditReportCommand");
+var de_CreateCertificateAuthorityAuditReportCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArgsException":
+    case "com.amazonaws.acmpca#InvalidArgsException":
+      throw await de_InvalidArgsExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "RequestInProgressException":
+    case "com.amazonaws.acmpca#RequestInProgressException":
+      throw await de_RequestInProgressExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCertificateAuthorityAuditReportCommandError");
+var de_CreatePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreatePermissionCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_CreatePermissionCommand");
+var de_CreatePermissionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.acmpca#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "PermissionAlreadyExistsException":
+    case "com.amazonaws.acmpca#PermissionAlreadyExistsException":
+      throw await de_PermissionAlreadyExistsExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreatePermissionCommandError");
+var de_DeleteCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteCertificateAuthorityCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteCertificateAuthorityCommand");
+var de_DeleteCertificateAuthorityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.acmpca#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteCertificateAuthorityCommandError");
+var de_DeletePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeletePermissionCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeletePermissionCommand");
+var de_DeletePermissionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeletePermissionCommandError");
+var de_DeletePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeletePolicyCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeletePolicyCommand");
+var de_DeletePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.acmpca#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "LockoutPreventedException":
+    case "com.amazonaws.acmpca#LockoutPreventedException":
+      throw await de_LockoutPreventedExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeletePolicyCommandError");
+var de_DescribeCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeCertificateAuthorityCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeCertificateAuthorityResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCertificateAuthorityCommand");
+var de_DescribeCertificateAuthorityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCertificateAuthorityCommandError");
+var de_DescribeCertificateAuthorityAuditReportCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeCertificateAuthorityAuditReportCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeCertificateAuthorityAuditReportResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCertificateAuthorityAuditReportCommand");
+var de_DescribeCertificateAuthorityAuditReportCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArgsException":
+    case "com.amazonaws.acmpca#InvalidArgsException":
+      throw await de_InvalidArgsExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCertificateAuthorityAuditReportCommandError");
+var de_GetCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCertificateCommandError(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_GetCertificateCommand");
+var de_GetCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "RequestInProgressException":
+    case "com.amazonaws.acmpca#RequestInProgressException":
+      throw await de_RequestInProgressExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCertificateCommandError");
+var de_GetCertificateAuthorityCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCertificateAuthorityCertificateCommandError(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_GetCertificateAuthorityCertificateCommand");
+var de_GetCertificateAuthorityCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCertificateAuthorityCertificateCommandError");
+var de_GetCertificateAuthorityCsrCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCertificateAuthorityCsrCommandError(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_GetCertificateAuthorityCsrCommand");
+var de_GetCertificateAuthorityCsrCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "RequestInProgressException":
+    case "com.amazonaws.acmpca#RequestInProgressException":
+      throw await de_RequestInProgressExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCertificateAuthorityCsrCommandError");
+var de_GetPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetPolicyCommandError(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_GetPolicyCommand");
+var de_GetPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetPolicyCommandError");
+var de_ImportCertificateAuthorityCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ImportCertificateAuthorityCertificateCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_ImportCertificateAuthorityCertificateCommand");
+var de_ImportCertificateAuthorityCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CertificateMismatchException":
+    case "com.amazonaws.acmpca#CertificateMismatchException":
+      throw await de_CertificateMismatchExceptionRes(parsedOutput, context);
+    case "ConcurrentModificationException":
+    case "com.amazonaws.acmpca#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.acmpca#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "MalformedCertificateException":
+    case "com.amazonaws.acmpca#MalformedCertificateException":
+      throw await de_MalformedCertificateExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "RequestInProgressException":
+    case "com.amazonaws.acmpca#RequestInProgressException":
+      throw await de_RequestInProgressExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ImportCertificateAuthorityCertificateCommandError");
+var de_IssueCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_IssueCertificateCommandError(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_IssueCertificateCommand");
+var de_IssueCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArgsException":
+    case "com.amazonaws.acmpca#InvalidArgsException":
+      throw await de_InvalidArgsExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.acmpca#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "MalformedCSRException":
+    case "com.amazonaws.acmpca#MalformedCSRException":
+      throw await de_MalformedCSRExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_IssueCertificateCommandError");
+var de_ListCertificateAuthoritiesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListCertificateAuthoritiesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListCertificateAuthoritiesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListCertificateAuthoritiesCommand");
+var de_ListCertificateAuthoritiesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidNextTokenException":
+    case "com.amazonaws.acmpca#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCertificateAuthoritiesCommandError");
+var de_ListPermissionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListPermissionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListPermissionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListPermissionsCommand");
+var de_ListPermissionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidNextTokenException":
+    case "com.amazonaws.acmpca#InvalidNextTokenException":
+      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListPermissionsCommandError");
+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 "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsCommandError");
+var de_PutPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutPolicyCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_PutPolicyCommand");
+var de_PutPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.acmpca#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidPolicyException":
+    case "com.amazonaws.acmpca#InvalidPolicyException":
+      throw await de_InvalidPolicyExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "LockoutPreventedException":
+    case "com.amazonaws.acmpca#LockoutPreventedException":
+      throw await de_LockoutPreventedExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutPolicyCommandError");
+var de_RestoreCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RestoreCertificateAuthorityCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RestoreCertificateAuthorityCommand");
+var de_RestoreCertificateAuthorityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RestoreCertificateAuthorityCommandError");
+var de_RevokeCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RevokeCertificateCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RevokeCertificateCommand");
+var de_RevokeCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.acmpca#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.acmpca#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.acmpca#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RequestAlreadyProcessedException":
+    case "com.amazonaws.acmpca#RequestAlreadyProcessedException":
+      throw await de_RequestAlreadyProcessedExceptionRes(parsedOutput, context);
+    case "RequestFailedException":
+    case "com.amazonaws.acmpca#RequestFailedException":
+      throw await de_RequestFailedExceptionRes(parsedOutput, context);
+    case "RequestInProgressException":
+    case "com.amazonaws.acmpca#RequestInProgressException":
+      throw await de_RequestInProgressExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RevokeCertificateCommandError");
+var de_TagCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagCertificateAuthorityCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_TagCertificateAuthorityCommand");
+var de_TagCertificateAuthorityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "InvalidTagException":
+    case "com.amazonaws.acmpca#InvalidTagException":
+      throw await de_InvalidTagExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.acmpca#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagCertificateAuthorityCommandError");
+var de_UntagCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagCertificateAuthorityCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_UntagCertificateAuthorityCommand");
+var de_UntagCertificateAuthorityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "InvalidTagException":
+    case "com.amazonaws.acmpca#InvalidTagException":
+      throw await de_InvalidTagExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagCertificateAuthorityCommandError");
+var de_UpdateCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateCertificateAuthorityCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_UpdateCertificateAuthorityCommand");
+var de_UpdateCertificateAuthorityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.acmpca#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InvalidArgsException":
+    case "com.amazonaws.acmpca#InvalidArgsException":
+      throw await de_InvalidArgsExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acmpca#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidPolicyException":
+    case "com.amazonaws.acmpca#InvalidPolicyException":
+      throw await de_InvalidPolicyExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acmpca#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acmpca#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateCertificateAuthorityCommandError");
+var de_CertificateMismatchExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CertificateMismatchException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CertificateMismatchExceptionRes");
+var de_ConcurrentModificationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ConcurrentModificationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ConcurrentModificationExceptionRes");
+var de_InvalidArgsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidArgsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidArgsExceptionRes");
+var de_InvalidArnExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidArnException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidArnExceptionRes");
+var de_InvalidNextTokenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidNextTokenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidNextTokenExceptionRes");
+var de_InvalidPolicyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidPolicyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidPolicyExceptionRes");
+var de_InvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidRequestExceptionRes");
+var de_InvalidStateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidStateException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidStateExceptionRes");
+var de_InvalidTagExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidTagException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidTagExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_LockoutPreventedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LockoutPreventedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LockoutPreventedExceptionRes");
+var de_MalformedCertificateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new MalformedCertificateException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_MalformedCertificateExceptionRes");
+var de_MalformedCSRExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new MalformedCSRException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_MalformedCSRExceptionRes");
+var de_PermissionAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new PermissionAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PermissionAlreadyExistsExceptionRes");
+var de_RequestAlreadyProcessedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new RequestAlreadyProcessedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_RequestAlreadyProcessedExceptionRes");
+var de_RequestFailedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new RequestFailedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_RequestFailedExceptionRes");
+var de_RequestInProgressExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new RequestInProgressException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_RequestInProgressExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyTagsExceptionRes");
+var se_ImportCertificateAuthorityCertificateRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Certificate: context.base64Encoder,
+    CertificateAuthorityArn: [],
+    CertificateChain: context.base64Encoder
+  });
+}, "se_ImportCertificateAuthorityCertificateRequest");
+var se_IssueCertificateRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    ApiPassthrough: import_smithy_client._json,
+    CertificateAuthorityArn: [],
+    Csr: context.base64Encoder,
+    IdempotencyToken: [],
+    SigningAlgorithm: [],
+    TemplateArn: [],
+    Validity: import_smithy_client._json,
+    ValidityNotBefore: import_smithy_client._json
+  });
+}, "se_IssueCertificateRequest");
+var de_CertificateAuthorities = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CertificateAuthority(entry, context);
+  });
+  return retVal;
+}, "de_CertificateAuthorities");
+var de_CertificateAuthority = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CertificateAuthorityConfiguration: import_smithy_client._json,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    FailureReason: import_smithy_client.expectString,
+    KeyStorageSecurityStandard: import_smithy_client.expectString,
+    LastStateChangeAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NotAfter: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NotBefore: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    OwnerAccount: import_smithy_client.expectString,
+    RestorableUntil: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    RevocationConfiguration: import_smithy_client._json,
+    Serial: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString,
+    UsageMode: import_smithy_client.expectString
+  });
+}, "de_CertificateAuthority");
+var de_DescribeCertificateAuthorityAuditReportResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AuditReportStatus: import_smithy_client.expectString,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    S3BucketName: import_smithy_client.expectString,
+    S3Key: import_smithy_client.expectString
+  });
+}, "de_DescribeCertificateAuthorityAuditReportResponse");
+var de_DescribeCertificateAuthorityResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CertificateAuthority: (_) => de_CertificateAuthority(_, context)
+  });
+}, "de_DescribeCertificateAuthorityResponse");
+var de_ListCertificateAuthoritiesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CertificateAuthorities: (_) => de_CertificateAuthorities(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListCertificateAuthoritiesResponse");
+var de_ListPermissionsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    Permissions: (_) => de_PermissionList(_, context)
+  });
+}, "de_ListPermissionsResponse");
+var de_Permission = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Actions: import_smithy_client._json,
+    CertificateAuthorityArn: import_smithy_client.expectString,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Policy: import_smithy_client.expectString,
+    Principal: import_smithy_client.expectString,
+    SourceAccount: import_smithy_client.expectString
+  });
+}, "de_Permission");
+var de_PermissionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Permission(entry, context);
+  });
+  return retVal;
+}, "de_PermissionList");
+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)(ACMPCAServiceException);
+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": `ACMPrivateCA.${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/CreateCertificateAuthorityAuditReportCommand.ts
+var _CreateCertificateAuthorityAuditReportCommand = class _CreateCertificateAuthorityAuditReportCommand 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("ACMPrivateCA", "CreateCertificateAuthorityAuditReport", {}).n("ACMPCAClient", "CreateCertificateAuthorityAuditReportCommand").f(void 0, void 0).ser(se_CreateCertificateAuthorityAuditReportCommand).de(de_CreateCertificateAuthorityAuditReportCommand).build() {
+};
+__name(_CreateCertificateAuthorityAuditReportCommand, "CreateCertificateAuthorityAuditReportCommand");
+var CreateCertificateAuthorityAuditReportCommand = _CreateCertificateAuthorityAuditReportCommand;
+
+// src/commands/CreateCertificateAuthorityCommand.ts
+
+
+
+
+var _CreateCertificateAuthorityCommand = class _CreateCertificateAuthorityCommand 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("ACMPrivateCA", "CreateCertificateAuthority", {}).n("ACMPCAClient", "CreateCertificateAuthorityCommand").f(void 0, void 0).ser(se_CreateCertificateAuthorityCommand).de(de_CreateCertificateAuthorityCommand).build() {
+};
+__name(_CreateCertificateAuthorityCommand, "CreateCertificateAuthorityCommand");
+var CreateCertificateAuthorityCommand = _CreateCertificateAuthorityCommand;
+
+// src/commands/CreatePermissionCommand.ts
+
+
+
+
+var _CreatePermissionCommand = class _CreatePermissionCommand 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("ACMPrivateCA", "CreatePermission", {}).n("ACMPCAClient", "CreatePermissionCommand").f(void 0, void 0).ser(se_CreatePermissionCommand).de(de_CreatePermissionCommand).build() {
+};
+__name(_CreatePermissionCommand, "CreatePermissionCommand");
+var CreatePermissionCommand = _CreatePermissionCommand;
+
+// src/commands/DeleteCertificateAuthorityCommand.ts
+
+
+
+
+var _DeleteCertificateAuthorityCommand = class _DeleteCertificateAuthorityCommand 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("ACMPrivateCA", "DeleteCertificateAuthority", {}).n("ACMPCAClient", "DeleteCertificateAuthorityCommand").f(void 0, void 0).ser(se_DeleteCertificateAuthorityCommand).de(de_DeleteCertificateAuthorityCommand).build() {
+};
+__name(_DeleteCertificateAuthorityCommand, "DeleteCertificateAuthorityCommand");
+var DeleteCertificateAuthorityCommand = _DeleteCertificateAuthorityCommand;
+
+// src/commands/DeletePermissionCommand.ts
+
+
+
+
+var _DeletePermissionCommand = class _DeletePermissionCommand 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("ACMPrivateCA", "DeletePermission", {}).n("ACMPCAClient", "DeletePermissionCommand").f(void 0, void 0).ser(se_DeletePermissionCommand).de(de_DeletePermissionCommand).build() {
+};
+__name(_DeletePermissionCommand, "DeletePermissionCommand");
+var DeletePermissionCommand = _DeletePermissionCommand;
+
+// src/commands/DeletePolicyCommand.ts
+
+
+
+
+var _DeletePolicyCommand = class _DeletePolicyCommand 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("ACMPrivateCA", "DeletePolicy", {}).n("ACMPCAClient", "DeletePolicyCommand").f(void 0, void 0).ser(se_DeletePolicyCommand).de(de_DeletePolicyCommand).build() {
+};
+__name(_DeletePolicyCommand, "DeletePolicyCommand");
+var DeletePolicyCommand = _DeletePolicyCommand;
+
+// src/commands/DescribeCertificateAuthorityAuditReportCommand.ts
+
+
+
+
+var _DescribeCertificateAuthorityAuditReportCommand = class _DescribeCertificateAuthorityAuditReportCommand 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("ACMPrivateCA", "DescribeCertificateAuthorityAuditReport", {}).n("ACMPCAClient", "DescribeCertificateAuthorityAuditReportCommand").f(void 0, void 0).ser(se_DescribeCertificateAuthorityAuditReportCommand).de(de_DescribeCertificateAuthorityAuditReportCommand).build() {
+};
+__name(_DescribeCertificateAuthorityAuditReportCommand, "DescribeCertificateAuthorityAuditReportCommand");
+var DescribeCertificateAuthorityAuditReportCommand = _DescribeCertificateAuthorityAuditReportCommand;
+
+// src/commands/DescribeCertificateAuthorityCommand.ts
+
+
+
+
+var _DescribeCertificateAuthorityCommand = class _DescribeCertificateAuthorityCommand 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("ACMPrivateCA", "DescribeCertificateAuthority", {}).n("ACMPCAClient", "DescribeCertificateAuthorityCommand").f(void 0, void 0).ser(se_DescribeCertificateAuthorityCommand).de(de_DescribeCertificateAuthorityCommand).build() {
+};
+__name(_DescribeCertificateAuthorityCommand, "DescribeCertificateAuthorityCommand");
+var DescribeCertificateAuthorityCommand = _DescribeCertificateAuthorityCommand;
+
+// src/commands/GetCertificateAuthorityCertificateCommand.ts
+
+
+
+
+var _GetCertificateAuthorityCertificateCommand = class _GetCertificateAuthorityCertificateCommand 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("ACMPrivateCA", "GetCertificateAuthorityCertificate", {}).n("ACMPCAClient", "GetCertificateAuthorityCertificateCommand").f(void 0, void 0).ser(se_GetCertificateAuthorityCertificateCommand).de(de_GetCertificateAuthorityCertificateCommand).build() {
+};
+__name(_GetCertificateAuthorityCertificateCommand, "GetCertificateAuthorityCertificateCommand");
+var GetCertificateAuthorityCertificateCommand = _GetCertificateAuthorityCertificateCommand;
+
+// src/commands/GetCertificateAuthorityCsrCommand.ts
+
+
+
+
+var _GetCertificateAuthorityCsrCommand = class _GetCertificateAuthorityCsrCommand 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("ACMPrivateCA", "GetCertificateAuthorityCsr", {}).n("ACMPCAClient", "GetCertificateAuthorityCsrCommand").f(void 0, void 0).ser(se_GetCertificateAuthorityCsrCommand).de(de_GetCertificateAuthorityCsrCommand).build() {
+};
+__name(_GetCertificateAuthorityCsrCommand, "GetCertificateAuthorityCsrCommand");
+var GetCertificateAuthorityCsrCommand = _GetCertificateAuthorityCsrCommand;
+
+// src/commands/GetCertificateCommand.ts
+
+
+
+
+var _GetCertificateCommand = class _GetCertificateCommand 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("ACMPrivateCA", "GetCertificate", {}).n("ACMPCAClient", "GetCertificateCommand").f(void 0, void 0).ser(se_GetCertificateCommand).de(de_GetCertificateCommand).build() {
+};
+__name(_GetCertificateCommand, "GetCertificateCommand");
+var GetCertificateCommand = _GetCertificateCommand;
+
+// src/commands/GetPolicyCommand.ts
+
+
+
+
+var _GetPolicyCommand = class _GetPolicyCommand 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("ACMPrivateCA", "GetPolicy", {}).n("ACMPCAClient", "GetPolicyCommand").f(void 0, void 0).ser(se_GetPolicyCommand).de(de_GetPolicyCommand).build() {
+};
+__name(_GetPolicyCommand, "GetPolicyCommand");
+var GetPolicyCommand = _GetPolicyCommand;
+
+// src/commands/ImportCertificateAuthorityCertificateCommand.ts
+
+
+
+
+var _ImportCertificateAuthorityCertificateCommand = class _ImportCertificateAuthorityCertificateCommand 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("ACMPrivateCA", "ImportCertificateAuthorityCertificate", {}).n("ACMPCAClient", "ImportCertificateAuthorityCertificateCommand").f(void 0, void 0).ser(se_ImportCertificateAuthorityCertificateCommand).de(de_ImportCertificateAuthorityCertificateCommand).build() {
+};
+__name(_ImportCertificateAuthorityCertificateCommand, "ImportCertificateAuthorityCertificateCommand");
+var ImportCertificateAuthorityCertificateCommand = _ImportCertificateAuthorityCertificateCommand;
+
+// src/commands/IssueCertificateCommand.ts
+
+
+
+
+var _IssueCertificateCommand = class _IssueCertificateCommand 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("ACMPrivateCA", "IssueCertificate", {}).n("ACMPCAClient", "IssueCertificateCommand").f(void 0, void 0).ser(se_IssueCertificateCommand).de(de_IssueCertificateCommand).build() {
+};
+__name(_IssueCertificateCommand, "IssueCertificateCommand");
+var IssueCertificateCommand = _IssueCertificateCommand;
+
+// src/commands/ListCertificateAuthoritiesCommand.ts
+
+
+
+
+var _ListCertificateAuthoritiesCommand = class _ListCertificateAuthoritiesCommand 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("ACMPrivateCA", "ListCertificateAuthorities", {}).n("ACMPCAClient", "ListCertificateAuthoritiesCommand").f(void 0, void 0).ser(se_ListCertificateAuthoritiesCommand).de(de_ListCertificateAuthoritiesCommand).build() {
+};
+__name(_ListCertificateAuthoritiesCommand, "ListCertificateAuthoritiesCommand");
+var ListCertificateAuthoritiesCommand = _ListCertificateAuthoritiesCommand;
+
+// src/commands/ListPermissionsCommand.ts
+
+
+
+
+var _ListPermissionsCommand = class _ListPermissionsCommand 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("ACMPrivateCA", "ListPermissions", {}).n("ACMPCAClient", "ListPermissionsCommand").f(void 0, void 0).ser(se_ListPermissionsCommand).de(de_ListPermissionsCommand).build() {
+};
+__name(_ListPermissionsCommand, "ListPermissionsCommand");
+var ListPermissionsCommand = _ListPermissionsCommand;
+
+// 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("ACMPrivateCA", "ListTags", {}).n("ACMPCAClient", "ListTagsCommand").f(void 0, void 0).ser(se_ListTagsCommand).de(de_ListTagsCommand).build() {
+};
+__name(_ListTagsCommand, "ListTagsCommand");
+var ListTagsCommand = _ListTagsCommand;
+
+// src/commands/PutPolicyCommand.ts
+
+
+
+
+var _PutPolicyCommand = class _PutPolicyCommand 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("ACMPrivateCA", "PutPolicy", {}).n("ACMPCAClient", "PutPolicyCommand").f(void 0, void 0).ser(se_PutPolicyCommand).de(de_PutPolicyCommand).build() {
+};
+__name(_PutPolicyCommand, "PutPolicyCommand");
+var PutPolicyCommand = _PutPolicyCommand;
+
+// src/commands/RestoreCertificateAuthorityCommand.ts
+
+
+
+
+var _RestoreCertificateAuthorityCommand = class _RestoreCertificateAuthorityCommand 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("ACMPrivateCA", "RestoreCertificateAuthority", {}).n("ACMPCAClient", "RestoreCertificateAuthorityCommand").f(void 0, void 0).ser(se_RestoreCertificateAuthorityCommand).de(de_RestoreCertificateAuthorityCommand).build() {
+};
+__name(_RestoreCertificateAuthorityCommand, "RestoreCertificateAuthorityCommand");
+var RestoreCertificateAuthorityCommand = _RestoreCertificateAuthorityCommand;
+
+// src/commands/RevokeCertificateCommand.ts
+
+
+
+
+var _RevokeCertificateCommand = class _RevokeCertificateCommand 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("ACMPrivateCA", "RevokeCertificate", {}).n("ACMPCAClient", "RevokeCertificateCommand").f(void 0, void 0).ser(se_RevokeCertificateCommand).de(de_RevokeCertificateCommand).build() {
+};
+__name(_RevokeCertificateCommand, "RevokeCertificateCommand");
+var RevokeCertificateCommand = _RevokeCertificateCommand;
+
+// src/commands/TagCertificateAuthorityCommand.ts
+
+
+
+
+var _TagCertificateAuthorityCommand = class _TagCertificateAuthorityCommand 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("ACMPrivateCA", "TagCertificateAuthority", {}).n("ACMPCAClient", "TagCertificateAuthorityCommand").f(void 0, void 0).ser(se_TagCertificateAuthorityCommand).de(de_TagCertificateAuthorityCommand).build() {
+};
+__name(_TagCertificateAuthorityCommand, "TagCertificateAuthorityCommand");
+var TagCertificateAuthorityCommand = _TagCertificateAuthorityCommand;
+
+// src/commands/UntagCertificateAuthorityCommand.ts
+
+
+
+
+var _UntagCertificateAuthorityCommand = class _UntagCertificateAuthorityCommand 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("ACMPrivateCA", "UntagCertificateAuthority", {}).n("ACMPCAClient", "UntagCertificateAuthorityCommand").f(void 0, void 0).ser(se_UntagCertificateAuthorityCommand).de(de_UntagCertificateAuthorityCommand).build() {
+};
+__name(_UntagCertificateAuthorityCommand, "UntagCertificateAuthorityCommand");
+var UntagCertificateAuthorityCommand = _UntagCertificateAuthorityCommand;
+
+// src/commands/UpdateCertificateAuthorityCommand.ts
+
+
+
+
+var _UpdateCertificateAuthorityCommand = class _UpdateCertificateAuthorityCommand 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("ACMPrivateCA", "UpdateCertificateAuthority", {}).n("ACMPCAClient", "UpdateCertificateAuthorityCommand").f(void 0, void 0).ser(se_UpdateCertificateAuthorityCommand).de(de_UpdateCertificateAuthorityCommand).build() {
+};
+__name(_UpdateCertificateAuthorityCommand, "UpdateCertificateAuthorityCommand");
+var UpdateCertificateAuthorityCommand = _UpdateCertificateAuthorityCommand;
+
+// src/ACMPCA.ts
+var commands = {
+  CreateCertificateAuthorityCommand,
+  CreateCertificateAuthorityAuditReportCommand,
+  CreatePermissionCommand,
+  DeleteCertificateAuthorityCommand,
+  DeletePermissionCommand,
+  DeletePolicyCommand,
+  DescribeCertificateAuthorityCommand,
+  DescribeCertificateAuthorityAuditReportCommand,
+  GetCertificateCommand,
+  GetCertificateAuthorityCertificateCommand,
+  GetCertificateAuthorityCsrCommand,
+  GetPolicyCommand,
+  ImportCertificateAuthorityCertificateCommand,
+  IssueCertificateCommand,
+  ListCertificateAuthoritiesCommand,
+  ListPermissionsCommand,
+  ListTagsCommand,
+  PutPolicyCommand,
+  RestoreCertificateAuthorityCommand,
+  RevokeCertificateCommand,
+  TagCertificateAuthorityCommand,
+  UntagCertificateAuthorityCommand,
+  UpdateCertificateAuthorityCommand
+};
+var _ACMPCA = class _ACMPCA extends ACMPCAClient {
+};
+__name(_ACMPCA, "ACMPCA");
+var ACMPCA = _ACMPCA;
+(0, import_smithy_client.createAggregatedClient)(commands, ACMPCA);
+
+// src/pagination/ListCertificateAuthoritiesPaginator.ts
+var import_core = require("@smithy/core");
+var paginateListCertificateAuthorities = (0, import_core.createPaginator)(ACMPCAClient, ListCertificateAuthoritiesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListPermissionsPaginator.ts
+
+var paginateListPermissions = (0, import_core.createPaginator)(ACMPCAClient, ListPermissionsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListTagsPaginator.ts
+
+var paginateListTags = (0, import_core.createPaginator)(ACMPCAClient, ListTagsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/waiters/waitForAuditReportCreated.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeCertificateAuthorityAuditReportCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.AuditReportStatus;
+      }, "returnComparator");
+      if (returnComparator() === "SUCCESS") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.AuditReportStatus;
+      }, "returnComparator");
+      if (returnComparator() === "FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForAuditReportCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForAuditReportCreated");
+var waitUntilAuditReportCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilAuditReportCreated");
+
+// src/waiters/waitForCertificateAuthorityCSRCreated.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetCertificateAuthorityCsrCommand(input));
+    reason = result;
+    return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "RequestInProgressException") {
+      return { state: import_util_waiter.WaiterState.RETRY, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForCertificateAuthorityCSRCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForCertificateAuthorityCSRCreated");
+var waitUntilCertificateAuthorityCSRCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilCertificateAuthorityCSRCreated");
+
+// src/waiters/waitForCertificateIssued.ts
+
+var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetCertificateCommand(input));
+    reason = result;
+    return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "RequestInProgressException") {
+      return { state: import_util_waiter.WaiterState.RETRY, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForCertificateIssued = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+}, "waitForCertificateIssued");
+var waitUntilCertificateIssued = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilCertificateIssued");
+
+// 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 = {
+  ACMPCA,
+  ACMPCAClient,
+  ACMPCAServiceException,
+  AccessMethodType,
+  ActionType,
+  AuditReportResponseFormat,
+  AuditReportStatus,
+  CertificateAuthorityStatus,
+  CertificateAuthorityType,
+  CertificateAuthorityUsageMode,
+  CertificateMismatchException,
+  ConcurrentModificationException,
+  CreateCertificateAuthorityAuditReportCommand,
+  CreateCertificateAuthorityCommand,
+  CreatePermissionCommand,
+  DeleteCertificateAuthorityCommand,
+  DeletePermissionCommand,
+  DeletePolicyCommand,
+  DescribeCertificateAuthorityAuditReportCommand,
+  DescribeCertificateAuthorityCommand,
+  ExtendedKeyUsageType,
+  FailureReason,
+  GetCertificateAuthorityCertificateCommand,
+  GetCertificateAuthorityCsrCommand,
+  GetCertificateCommand,
+  GetPolicyCommand,
+  ImportCertificateAuthorityCertificateCommand,
+  InvalidArgsException,
+  InvalidArnException,
+  InvalidNextTokenException,
+  InvalidPolicyException,
+  InvalidRequestException,
+  InvalidStateException,
+  InvalidTagException,
+  IssueCertificateCommand,
+  KeyAlgorithm,
+  KeyStorageSecurityStandard,
+  LimitExceededException,
+  ListCertificateAuthoritiesCommand,
+  ListPermissionsCommand,
+  ListTagsCommand,
+  LockoutPreventedException,
+  MalformedCSRException,
+  MalformedCertificateException,
+  PermissionAlreadyExistsException,
+  PolicyQualifierId,
+  PutPolicyCommand,
+  RequestAlreadyProcessedException,
+  RequestFailedException,
+  RequestInProgressException,
+  ResourceNotFoundException,
+  ResourceOwner,
+  RestoreCertificateAuthorityCommand,
+  RevocationReason,
+  RevokeCertificateCommand,
+  S3ObjectAcl,
+  SigningAlgorithm,
+  TagCertificateAuthorityCommand,
+  TooManyTagsException,
+  UntagCertificateAuthorityCommand,
+  UpdateCertificateAuthorityCommand,
+  ValidityPeriodType,
+  __Client,
+  paginateListCertificateAuthorities,
+  paginateListPermissions,
+  paginateListTags,
+  waitForAuditReportCreated,
+  waitForCertificateAuthorityCSRCreated,
+  waitForCertificateIssued,
+  waitUntilAuditReportCreated,
+  waitUntilCertificateAuthorityCSRCreated,
+  waitUntilCertificateIssued
+});