npm - @aws-sdk/client-acm-pca - Versions diffs - 3.901.0 → 3.907.0 - Mend

@aws-sdk/client-acm-pca 3.901.0 → 3.907.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist-cjs/index.js +1749 -1975
package/package.json +6 -6

package/dist-cjs/index.js CHANGED Viewed

@@ -1,2052 +1,1826 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  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,
-  CrlType: () => CrlType,
-  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(index_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_user_agent = require("@aws-sdk/middleware-user-agent");
-var import_config_resolver = require("@smithy/config-resolver");
-var import_core = require("@smithy/core");
-var import_middleware_content_length = require("@smithy/middleware-content-length");
-var import_middleware_endpoint = require("@smithy/middleware-endpoint");
-var import_middleware_retry = require("@smithy/middleware-retry");
-var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
-// src/endpoint/EndpointParameters.ts
-var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
-  return Object.assign(options, {
-    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" }
+'use strict';
+var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
+var middlewareLogger = require('@aws-sdk/middleware-logger');
+var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
+var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
+var configResolver = require('@smithy/config-resolver');
+var core = require('@smithy/core');
+var middlewareContentLength = require('@smithy/middleware-content-length');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var middlewareRetry = require('@smithy/middleware-retry');
+var smithyClient = require('@smithy/smithy-client');
+var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
+var runtimeConfig = require('./runtimeConfig');
+var regionConfigResolver = require('@aws-sdk/region-config-resolver');
+var protocolHttp = require('@smithy/protocol-http');
+var middlewareSerde = require('@smithy/middleware-serde');
+var core$1 = require('@aws-sdk/core');
+var utilWaiter = require('@smithy/util-waiter');
+const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "acm-pca",
+    });
 };
-// 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");
-// src/auth/httpAuthExtensionConfiguration.ts
-var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
-  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
-  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
-  let _credentials = runtimeConfig.credentials;
-  return {
-    setHttpAuthScheme(httpAuthScheme) {
-      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
-      if (index === -1) {
-        _httpAuthSchemes.push(httpAuthScheme);
-      } else {
-        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
-      }
-    },
-    httpAuthSchemes() {
-      return _httpAuthSchemes;
-    },
-    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
-      _httpAuthSchemeProvider = httpAuthSchemeProvider;
-    },
-    httpAuthSchemeProvider() {
-      return _httpAuthSchemeProvider;
-    },
-    setCredentials(credentials) {
-      _credentials = credentials;
-    },
-    credentials() {
-      return _credentials;
+const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+};
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
+class ACMPCAClient extends smithyClient.Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
+        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
+        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
+        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+        this.config = _config_8;
+        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
+        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
+        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultACMPCAHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
     }
-  };
-}, "getHttpAuthExtensionConfiguration");
-var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
-  return {
-    httpAuthSchemes: config.httpAuthSchemes(),
-    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
-    credentials: config.credentials()
-  };
-}, "resolveHttpAuthRuntimeConfig");
-// src/runtimeExtensions.ts
-var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
-  const extensionConfiguration = Object.assign(
-    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
-    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
-    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
-    getHttpAuthExtensionConfiguration(runtimeConfig)
-  );
-  extensions.forEach((extension) => extension.configure(extensionConfiguration));
-  return Object.assign(
-    runtimeConfig,
-    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
-    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
-    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
-    resolveHttpAuthRuntimeConfig(extensionConfiguration)
-  );
-}, "resolveRuntimeExtensions");
-// src/ACMPCAClient.ts
-var ACMPCAClient = class extends import_smithy_client.Client {
-  static {
-    __name(this, "ACMPCAClient");
-  }
-  /**
-   * The resolved configuration of ACMPCAClient class. This is resolved and normalized from the {@link ACMPCAClientConfig | constructor configuration interface}.
-   */
-  config;
-  constructor(...[configuration]) {
-    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
-    super(_config_0);
-    this.initConfig = _config_0;
-    const _config_1 = resolveClientEndpointParameters(_config_0);
-    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
-    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
-    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
-    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
-    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
-    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
-    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
-    this.config = _config_8;
-    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
-    this.middlewareStack.use(
-      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
-        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultACMPCAHttpAuthSchemeParametersProvider,
-        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
-          "aws.auth#sigv4": config.credentials
-        }), "identityProviderConfigProvider")
-      })
-    );
-    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
-  }
-  /**
-   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-   */
-  destroy() {
-    super.destroy();
-  }
-};
-// src/ACMPCA.ts
-// src/commands/CreateCertificateAuthorityAuditReportCommand.ts
-var import_middleware_serde = require("@smithy/middleware-serde");
-// src/protocols/Aws_json1_1.ts
-var import_core2 = require("@aws-sdk/core");
+    destroy() {
+        super.destroy();
+    }
+}
+class ACMPCAServiceException extends smithyClient.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, ACMPCAServiceException.prototype);
+    }
+}
-// src/models/ACMPCAServiceException.ts
+const AccessMethodType = {
+    CA_REPOSITORY: "CA_REPOSITORY",
+    RESOURCE_PKI_MANIFEST: "RESOURCE_PKI_MANIFEST",
+    RESOURCE_PKI_NOTIFY: "RESOURCE_PKI_NOTIFY",
+};
+const KeyAlgorithm = {
+    EC_prime256v1: "EC_prime256v1",
+    EC_secp384r1: "EC_secp384r1",
+    EC_secp521r1: "EC_secp521r1",
+    RSA_2048: "RSA_2048",
+    RSA_3072: "RSA_3072",
+    RSA_4096: "RSA_4096",
+    SM2: "SM2",
+};
+const SigningAlgorithm = {
+    SHA256WITHECDSA: "SHA256WITHECDSA",
+    SHA256WITHRSA: "SHA256WITHRSA",
+    SHA384WITHECDSA: "SHA384WITHECDSA",
+    SHA384WITHRSA: "SHA384WITHRSA",
+    SHA512WITHECDSA: "SHA512WITHECDSA",
+    SHA512WITHRSA: "SHA512WITHRSA",
+    SM3WITHSM2: "SM3WITHSM2",
+};
+const CertificateAuthorityType = {
+    ROOT: "ROOT",
+    SUBORDINATE: "SUBORDINATE",
+};
+const KeyStorageSecurityStandard = {
+    CCPC_LEVEL_1_OR_HIGHER: "CCPC_LEVEL_1_OR_HIGHER",
+    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",
+};
+const CrlType = {
+    COMPLETE: "COMPLETE",
+    PARTITIONED: "PARTITIONED",
+};
+const S3ObjectAcl = {
+    BUCKET_OWNER_FULL_CONTROL: "BUCKET_OWNER_FULL_CONTROL",
+    PUBLIC_READ: "PUBLIC_READ",
+};
+const CertificateAuthorityUsageMode = {
+    GENERAL_PURPOSE: "GENERAL_PURPOSE",
+    SHORT_LIVED_CERTIFICATE: "SHORT_LIVED_CERTIFICATE",
+};
+class InvalidArgsException extends ACMPCAServiceException {
+    name = "InvalidArgsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidArgsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidArgsException.prototype);
+    }
+}
+class InvalidPolicyException extends ACMPCAServiceException {
+    name = "InvalidPolicyException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidPolicyException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidPolicyException.prototype);
+    }
+}
+class InvalidTagException extends ACMPCAServiceException {
+    name = "InvalidTagException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTagException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTagException.prototype);
+    }
+}
+class LimitExceededException extends ACMPCAServiceException {
+    name = "LimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LimitExceededException.prototype);
+    }
+}
+const AuditReportResponseFormat = {
+    CSV: "CSV",
+    JSON: "JSON",
+};
+class InvalidArnException extends ACMPCAServiceException {
+    name = "InvalidArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidArnException.prototype);
+    }
+}
+class InvalidStateException extends ACMPCAServiceException {
+    name = "InvalidStateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidStateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidStateException.prototype);
+    }
+}
+class RequestFailedException extends ACMPCAServiceException {
+    name = "RequestFailedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RequestFailedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RequestFailedException.prototype);
+    }
+}
+class RequestInProgressException extends ACMPCAServiceException {
+    name = "RequestInProgressException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RequestInProgressException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RequestInProgressException.prototype);
+    }
+}
+class ResourceNotFoundException extends ACMPCAServiceException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+const ActionType = {
+    GetCertificate: "GetCertificate",
+    IssueCertificate: "IssueCertificate",
+    ListPermissions: "ListPermissions",
+};
+class PermissionAlreadyExistsException extends ACMPCAServiceException {
+    name = "PermissionAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PermissionAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PermissionAlreadyExistsException.prototype);
+    }
+}
+class ConcurrentModificationException extends ACMPCAServiceException {
+    name = "ConcurrentModificationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConcurrentModificationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
+    }
+}
+class LockoutPreventedException extends ACMPCAServiceException {
+    name = "LockoutPreventedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LockoutPreventedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LockoutPreventedException.prototype);
+    }
+}
+const FailureReason = {
+    OTHER: "OTHER",
+    REQUEST_TIMED_OUT: "REQUEST_TIMED_OUT",
+    UNSUPPORTED_ALGORITHM: "UNSUPPORTED_ALGORITHM",
+};
+const CertificateAuthorityStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETED: "DELETED",
+    DISABLED: "DISABLED",
+    EXPIRED: "EXPIRED",
+    FAILED: "FAILED",
+    PENDING_CERTIFICATE: "PENDING_CERTIFICATE",
+};
+const AuditReportStatus = {
+    CREATING: "CREATING",
+    FAILED: "FAILED",
+    SUCCESS: "SUCCESS",
+};
+class CertificateMismatchException extends ACMPCAServiceException {
+    name = "CertificateMismatchException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CertificateMismatchException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CertificateMismatchException.prototype);
+    }
+}
+class InvalidRequestException extends ACMPCAServiceException {
+    name = "InvalidRequestException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRequestException.prototype);
+    }
+}
+class MalformedCertificateException extends ACMPCAServiceException {
+    name = "MalformedCertificateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MalformedCertificateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MalformedCertificateException.prototype);
+    }
+}
+const PolicyQualifierId = {
+    CPS: "CPS",
+};
+const 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",
+};
+const ValidityPeriodType = {
+    ABSOLUTE: "ABSOLUTE",
+    DAYS: "DAYS",
+    END_DATE: "END_DATE",
+    MONTHS: "MONTHS",
+    YEARS: "YEARS",
+};
+class MalformedCSRException extends ACMPCAServiceException {
+    name = "MalformedCSRException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MalformedCSRException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MalformedCSRException.prototype);
+    }
+}
+class InvalidNextTokenException extends ACMPCAServiceException {
+    name = "InvalidNextTokenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidNextTokenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidNextTokenException.prototype);
+    }
+}
+const ResourceOwner = {
+    OTHER_ACCOUNTS: "OTHER_ACCOUNTS",
+    SELF: "SELF",
+};
+class RequestAlreadyProcessedException extends ACMPCAServiceException {
+    name = "RequestAlreadyProcessedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RequestAlreadyProcessedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RequestAlreadyProcessedException.prototype);
+    }
+}
+const 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",
+};
+class TooManyTagsException extends ACMPCAServiceException {
+    name = "TooManyTagsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TooManyTagsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TooManyTagsException.prototype);
+    }
+}
-var ACMPCAServiceException = class _ACMPCAServiceException extends import_smithy_client.ServiceException {
-  static {
-    __name(this, "ACMPCAServiceException");
-  }
-  /**
-   * @internal
-   */
-  constructor(options) {
-    super(options);
-    Object.setPrototypeOf(this, _ACMPCAServiceException.prototype);
-  }
+const se_CreateCertificateAuthorityCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateCertificateAuthority");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateCertificateAuthorityAuditReportCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateCertificateAuthorityAuditReport");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreatePermissionCommand = async (input, context) => {
+    const headers = sharedHeaders("CreatePermission");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeleteCertificateAuthorityCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteCertificateAuthority");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeletePermissionCommand = async (input, context) => {
+    const headers = sharedHeaders("DeletePermission");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeletePolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("DeletePolicy");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DescribeCertificateAuthorityCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeCertificateAuthority");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DescribeCertificateAuthorityAuditReportCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeCertificateAuthorityAuditReport");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetCertificateCommand = async (input, context) => {
+    const headers = sharedHeaders("GetCertificate");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetCertificateAuthorityCertificateCommand = async (input, context) => {
+    const headers = sharedHeaders("GetCertificateAuthorityCertificate");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetCertificateAuthorityCsrCommand = async (input, context) => {
+    const headers = sharedHeaders("GetCertificateAuthorityCsr");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetPolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("GetPolicy");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ImportCertificateAuthorityCertificateCommand = async (input, context) => {
+    const headers = sharedHeaders("ImportCertificateAuthorityCertificate");
+    let body;
+    body = JSON.stringify(se_ImportCertificateAuthorityCertificateRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_IssueCertificateCommand = async (input, context) => {
+    const headers = sharedHeaders("IssueCertificate");
+    let body;
+    body = JSON.stringify(se_IssueCertificateRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListCertificateAuthoritiesCommand = async (input, context) => {
+    const headers = sharedHeaders("ListCertificateAuthorities");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListPermissionsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListPermissions");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListTagsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListTags");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_PutPolicyCommand = async (input, context) => {
+    const headers = sharedHeaders("PutPolicy");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_RestoreCertificateAuthorityCommand = async (input, context) => {
+    const headers = sharedHeaders("RestoreCertificateAuthority");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_RevokeCertificateCommand = async (input, context) => {
+    const headers = sharedHeaders("RevokeCertificate");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_TagCertificateAuthorityCommand = async (input, context) => {
+    const headers = sharedHeaders("TagCertificateAuthority");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UntagCertificateAuthorityCommand = async (input, context) => {
+    const headers = sharedHeaders("UntagCertificateAuthority");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateCertificateAuthorityCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateCertificateAuthority");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const de_CreateCertificateAuthorityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateCertificateAuthorityAuditReportCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreatePermissionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_DeleteCertificateAuthorityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_DeletePermissionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_DeletePolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_DescribeCertificateAuthorityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeCertificateAuthorityResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DescribeCertificateAuthorityAuditReportCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeCertificateAuthorityAuditReportResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetCertificateCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetCertificateAuthorityCertificateCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetCertificateAuthorityCsrCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ImportCertificateAuthorityCertificateCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_IssueCertificateCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListCertificateAuthoritiesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListCertificateAuthoritiesResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListPermissionsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListPermissionsResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListTagsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_PutPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_RestoreCertificateAuthorityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_RevokeCertificateCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_TagCertificateAuthorityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_UntagCertificateAuthorityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_UpdateCertificateAuthorityCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    await smithyClient.collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return response;
+};
+const de_CommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await core$1.parseJsonErrorBody(output.body, context),
+    };
+    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidArgsException":
+        case "com.amazonaws.acmpca#InvalidArgsException":
+            throw await de_InvalidArgsExceptionRes(parsedOutput);
+        case "InvalidPolicyException":
+        case "com.amazonaws.acmpca#InvalidPolicyException":
+            throw await de_InvalidPolicyExceptionRes(parsedOutput);
+        case "InvalidTagException":
+        case "com.amazonaws.acmpca#InvalidTagException":
+            throw await de_InvalidTagExceptionRes(parsedOutput);
+        case "LimitExceededException":
+        case "com.amazonaws.acmpca#LimitExceededException":
+            throw await de_LimitExceededExceptionRes(parsedOutput);
+        case "InvalidArnException":
+        case "com.amazonaws.acmpca#InvalidArnException":
+            throw await de_InvalidArnExceptionRes(parsedOutput);
+        case "InvalidStateException":
+        case "com.amazonaws.acmpca#InvalidStateException":
+            throw await de_InvalidStateExceptionRes(parsedOutput);
+        case "RequestFailedException":
+        case "com.amazonaws.acmpca#RequestFailedException":
+            throw await de_RequestFailedExceptionRes(parsedOutput);
+        case "RequestInProgressException":
+        case "com.amazonaws.acmpca#RequestInProgressException":
+            throw await de_RequestInProgressExceptionRes(parsedOutput);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.acmpca#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
+        case "PermissionAlreadyExistsException":
+        case "com.amazonaws.acmpca#PermissionAlreadyExistsException":
+            throw await de_PermissionAlreadyExistsExceptionRes(parsedOutput);
+        case "ConcurrentModificationException":
+        case "com.amazonaws.acmpca#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput);
+        case "LockoutPreventedException":
+        case "com.amazonaws.acmpca#LockoutPreventedException":
+            throw await de_LockoutPreventedExceptionRes(parsedOutput);
+        case "CertificateMismatchException":
+        case "com.amazonaws.acmpca#CertificateMismatchException":
+            throw await de_CertificateMismatchExceptionRes(parsedOutput);
+        case "InvalidRequestException":
+        case "com.amazonaws.acmpca#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput);
+        case "MalformedCertificateException":
+        case "com.amazonaws.acmpca#MalformedCertificateException":
+            throw await de_MalformedCertificateExceptionRes(parsedOutput);
+        case "MalformedCSRException":
+        case "com.amazonaws.acmpca#MalformedCSRException":
+            throw await de_MalformedCSRExceptionRes(parsedOutput);
+        case "InvalidNextTokenException":
+        case "com.amazonaws.acmpca#InvalidNextTokenException":
+            throw await de_InvalidNextTokenExceptionRes(parsedOutput);
+        case "RequestAlreadyProcessedException":
+        case "com.amazonaws.acmpca#RequestAlreadyProcessedException":
+            throw await de_RequestAlreadyProcessedExceptionRes(parsedOutput);
+        case "TooManyTagsException":
+        case "com.amazonaws.acmpca#TooManyTagsException":
+            throw await de_TooManyTagsExceptionRes(parsedOutput);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
 };
-// 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",
-  EC_secp521r1: "EC_secp521r1",
-  RSA_2048: "RSA_2048",
-  RSA_3072: "RSA_3072",
-  RSA_4096: "RSA_4096",
-  SM2: "SM2"
-};
-var SigningAlgorithm = {
-  SHA256WITHECDSA: "SHA256WITHECDSA",
-  SHA256WITHRSA: "SHA256WITHRSA",
-  SHA384WITHECDSA: "SHA384WITHECDSA",
-  SHA384WITHRSA: "SHA384WITHRSA",
-  SHA512WITHECDSA: "SHA512WITHECDSA",
-  SHA512WITHRSA: "SHA512WITHRSA",
-  SM3WITHSM2: "SM3WITHSM2"
-};
-var CertificateAuthorityType = {
-  ROOT: "ROOT",
-  SUBORDINATE: "SUBORDINATE"
-};
-var KeyStorageSecurityStandard = {
-  CCPC_LEVEL_1_OR_HIGHER: "CCPC_LEVEL_1_OR_HIGHER",
-  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 CrlType = {
-  COMPLETE: "COMPLETE",
-  PARTITIONED: "PARTITIONED"
-};
-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 {
-  static {
-    __name(this, "InvalidArgsException");
-  }
-  name = "InvalidArgsException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidArgsException",
-      $fault: "client",
-      ...opts
+const de_CertificateMismatchExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new CertificateMismatchException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidArgsException.prototype);
-  }
-};
-var InvalidPolicyException = class _InvalidPolicyException extends ACMPCAServiceException {
-  static {
-    __name(this, "InvalidPolicyException");
-  }
-  name = "InvalidPolicyException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidPolicyException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ConcurrentModificationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ConcurrentModificationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidPolicyException.prototype);
-  }
-};
-var InvalidTagException = class _InvalidTagException extends ACMPCAServiceException {
-  static {
-    __name(this, "InvalidTagException");
-  }
-  name = "InvalidTagException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidTagException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidArgsExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidArgsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidTagException.prototype);
-  }
-};
-var LimitExceededException = class _LimitExceededException extends ACMPCAServiceException {
-  static {
-    __name(this, "LimitExceededException");
-  }
-  name = "LimitExceededException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LimitExceededException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidArnExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidArnException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _LimitExceededException.prototype);
-  }
-};
-var AuditReportResponseFormat = {
-  CSV: "CSV",
-  JSON: "JSON"
-};
-var InvalidArnException = class _InvalidArnException extends ACMPCAServiceException {
-  static {
-    __name(this, "InvalidArnException");
-  }
-  name = "InvalidArnException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidArnException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidNextTokenExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidNextTokenException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidArnException.prototype);
-  }
-};
-var InvalidStateException = class _InvalidStateException extends ACMPCAServiceException {
-  static {
-    __name(this, "InvalidStateException");
-  }
-  name = "InvalidStateException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidStateException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidPolicyExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidPolicyException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidStateException.prototype);
-  }
-};
-var RequestFailedException = class _RequestFailedException extends ACMPCAServiceException {
-  static {
-    __name(this, "RequestFailedException");
-  }
-  name = "RequestFailedException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RequestFailedException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidRequestException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _RequestFailedException.prototype);
-  }
-};
-var RequestInProgressException = class _RequestInProgressException extends ACMPCAServiceException {
-  static {
-    __name(this, "RequestInProgressException");
-  }
-  name = "RequestInProgressException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RequestInProgressException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidStateExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidStateException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _RequestInProgressException.prototype);
-  }
-};
-var ResourceNotFoundException = class _ResourceNotFoundException extends ACMPCAServiceException {
-  static {
-    __name(this, "ResourceNotFoundException");
-  }
-  name = "ResourceNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ResourceNotFoundException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidTagExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidTagException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
-  }
-};
-var ActionType = {
-  GetCertificate: "GetCertificate",
-  IssueCertificate: "IssueCertificate",
-  ListPermissions: "ListPermissions"
-};
-var PermissionAlreadyExistsException = class _PermissionAlreadyExistsException extends ACMPCAServiceException {
-  static {
-    __name(this, "PermissionAlreadyExistsException");
-  }
-  name = "PermissionAlreadyExistsException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "PermissionAlreadyExistsException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new LimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _PermissionAlreadyExistsException.prototype);
-  }
-};
-var ConcurrentModificationException = class _ConcurrentModificationException extends ACMPCAServiceException {
-  static {
-    __name(this, "ConcurrentModificationException");
-  }
-  name = "ConcurrentModificationException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ConcurrentModificationException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_LockoutPreventedExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new LockoutPreventedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);
-  }
-};
-var LockoutPreventedException = class _LockoutPreventedException extends ACMPCAServiceException {
-  static {
-    __name(this, "LockoutPreventedException");
-  }
-  name = "LockoutPreventedException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LockoutPreventedException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_MalformedCertificateExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new MalformedCertificateException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _LockoutPreventedException.prototype);
-  }
-};
-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 {
-  static {
-    __name(this, "CertificateMismatchException");
-  }
-  name = "CertificateMismatchException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "CertificateMismatchException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_MalformedCSRExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new MalformedCSRException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _CertificateMismatchException.prototype);
-  }
-};
-var InvalidRequestException = class _InvalidRequestException extends ACMPCAServiceException {
-  static {
-    __name(this, "InvalidRequestException");
-  }
-  name = "InvalidRequestException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidRequestException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_PermissionAlreadyExistsExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new PermissionAlreadyExistsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidRequestException.prototype);
-  }
-};
-var MalformedCertificateException = class _MalformedCertificateException extends ACMPCAServiceException {
-  static {
-    __name(this, "MalformedCertificateException");
-  }
-  name = "MalformedCertificateException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "MalformedCertificateException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_RequestAlreadyProcessedExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new RequestAlreadyProcessedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _MalformedCertificateException.prototype);
-  }
-};
-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 {
-  static {
-    __name(this, "MalformedCSRException");
-  }
-  name = "MalformedCSRException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "MalformedCSRException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_RequestFailedExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new RequestFailedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _MalformedCSRException.prototype);
-  }
-};
-var InvalidNextTokenException = class _InvalidNextTokenException extends ACMPCAServiceException {
-  static {
-    __name(this, "InvalidNextTokenException");
-  }
-  name = "InvalidNextTokenException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidNextTokenException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_RequestInProgressExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new RequestInProgressException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidNextTokenException.prototype);
-  }
-};
-var ResourceOwner = {
-  OTHER_ACCOUNTS: "OTHER_ACCOUNTS",
-  SELF: "SELF"
-};
-var RequestAlreadyProcessedException = class _RequestAlreadyProcessedException extends ACMPCAServiceException {
-  static {
-    __name(this, "RequestAlreadyProcessedException");
-  }
-  name = "RequestAlreadyProcessedException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RequestAlreadyProcessedException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _RequestAlreadyProcessedException.prototype);
-  }
-};
-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 {
-  static {
-    __name(this, "TooManyTagsException");
-  }
-  name = "TooManyTagsException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TooManyTagsException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new TooManyTagsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
-  }
-};
-// 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_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateCertificateAuthorityCommand");
-var de_CreateCertificateAuthorityAuditReportCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateCertificateAuthorityAuditReportCommand");
-var de_CreatePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_CreatePermissionCommand");
-var de_DeleteCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_DeleteCertificateAuthorityCommand");
-var de_DeletePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_DeletePermissionCommand");
-var de_DeletePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_DeletePolicyCommand");
-var de_DescribeCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DescribeCertificateAuthorityResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeCertificateAuthorityCommand");
-var de_DescribeCertificateAuthorityAuditReportCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DescribeCertificateAuthorityAuditReportResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeCertificateAuthorityAuditReportCommand");
-var de_GetCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetCertificateCommand");
-var de_GetCertificateAuthorityCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetCertificateAuthorityCertificateCommand");
-var de_GetCertificateAuthorityCsrCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetCertificateAuthorityCsrCommand");
-var de_GetPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetPolicyCommand");
-var de_ImportCertificateAuthorityCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_ImportCertificateAuthorityCertificateCommand");
-var de_IssueCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_IssueCertificateCommand");
-var de_ListCertificateAuthoritiesCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListCertificateAuthoritiesResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListCertificateAuthoritiesCommand");
-var de_ListPermissionsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListPermissionsResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListPermissionsCommand");
-var de_ListTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListTagsCommand");
-var de_PutPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_PutPolicyCommand");
-var de_RestoreCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RestoreCertificateAuthorityCommand");
-var de_RevokeCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RevokeCertificateCommand");
-var de_TagCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_TagCertificateAuthorityCommand");
-var de_UntagCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_UntagCertificateAuthorityCommand");
-var de_UpdateCertificateAuthorityCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_UpdateCertificateAuthorityCommand");
-var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
-  const parsedOutput = {
-    ...output,
-    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
-  };
-  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
-  switch (errorCode) {
-    case "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);
-    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);
-    case "PermissionAlreadyExistsException":
-    case "com.amazonaws.acmpca#PermissionAlreadyExistsException":
-      throw await de_PermissionAlreadyExistsExceptionRes(parsedOutput, context);
-    case "ConcurrentModificationException":
-    case "com.amazonaws.acmpca#ConcurrentModificationException":
-      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
-    case "LockoutPreventedException":
-    case "com.amazonaws.acmpca#LockoutPreventedException":
-      throw await de_LockoutPreventedExceptionRes(parsedOutput, context);
-    case "CertificateMismatchException":
-    case "com.amazonaws.acmpca#CertificateMismatchException":
-      throw await de_CertificateMismatchExceptionRes(parsedOutput, context);
-    case "InvalidRequestException":
-    case "com.amazonaws.acmpca#InvalidRequestException":
-      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
-    case "MalformedCertificateException":
-    case "com.amazonaws.acmpca#MalformedCertificateException":
-      throw await de_MalformedCertificateExceptionRes(parsedOutput, context);
-    case "MalformedCSRException":
-    case "com.amazonaws.acmpca#MalformedCSRException":
-      throw await de_MalformedCSRExceptionRes(parsedOutput, context);
-    case "InvalidNextTokenException":
-    case "com.amazonaws.acmpca#InvalidNextTokenException":
-      throw await de_InvalidNextTokenExceptionRes(parsedOutput, context);
-    case "RequestAlreadyProcessedException":
-    case "com.amazonaws.acmpca#RequestAlreadyProcessedException":
-      throw await de_RequestAlreadyProcessedExceptionRes(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_CommandError");
-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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreatedAt"),
-    FailureReason: import_smithy_client.expectString,
-    KeyStorageSecurityStandard: import_smithy_client.expectString,
-    LastStateChangeAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "LastStateChangeAt"),
-    NotAfter: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "NotAfter"),
-    NotBefore: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "NotBefore"),
-    OwnerAccount: import_smithy_client.expectString,
-    RestorableUntil: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "RestorableUntil"),
-    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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreatedAt"),
-    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: /* @__PURE__ */ __name((_) => de_CertificateAuthority(_, context), "CertificateAuthority")
-  });
-}, "de_DescribeCertificateAuthorityResponse");
-var de_ListCertificateAuthoritiesResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    CertificateAuthorities: /* @__PURE__ */ __name((_) => de_CertificateAuthorities(_, context), "CertificateAuthorities"),
-    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: /* @__PURE__ */ __name((_) => de_PermissionList(_, context), "Permissions")
-  });
-}, "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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreatedAt"),
-    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 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");
-// src/commands/CreateCertificateAuthorityAuditReportCommand.ts
-var CreateCertificateAuthorityAuditReportCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "CreateCertificateAuthorityAuditReport", {}).n("ACMPCAClient", "CreateCertificateAuthorityAuditReportCommand").f(void 0, void 0).ser(se_CreateCertificateAuthorityAuditReportCommand).de(de_CreateCertificateAuthorityAuditReportCommand).build() {
-  static {
-    __name(this, "CreateCertificateAuthorityAuditReportCommand");
-  }
+    return smithyClient.decorateServiceException(exception, body);
 };
-// src/commands/CreateCertificateAuthorityCommand.ts
-var CreateCertificateAuthorityCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "CreateCertificateAuthority", {}).n("ACMPCAClient", "CreateCertificateAuthorityCommand").f(void 0, void 0).ser(se_CreateCertificateAuthorityCommand).de(de_CreateCertificateAuthorityCommand).build() {
-  static {
-    __name(this, "CreateCertificateAuthorityCommand");
-  }
+const se_ImportCertificateAuthorityCertificateRequest = (input, context) => {
+    return smithyClient.take(input, {
+        Certificate: context.base64Encoder,
+        CertificateAuthorityArn: [],
+        CertificateChain: context.base64Encoder,
+    });
 };
-// src/commands/CreatePermissionCommand.ts
-var CreatePermissionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "CreatePermission", {}).n("ACMPCAClient", "CreatePermissionCommand").f(void 0, void 0).ser(se_CreatePermissionCommand).de(de_CreatePermissionCommand).build() {
-  static {
-    __name(this, "CreatePermissionCommand");
-  }
+const se_IssueCertificateRequest = (input, context) => {
+    return smithyClient.take(input, {
+        ApiPassthrough: smithyClient._json,
+        CertificateAuthorityArn: [],
+        Csr: context.base64Encoder,
+        IdempotencyToken: [],
+        SigningAlgorithm: [],
+        TemplateArn: [],
+        Validity: smithyClient._json,
+        ValidityNotBefore: smithyClient._json,
+    });
 };
-// src/commands/DeleteCertificateAuthorityCommand.ts
-var DeleteCertificateAuthorityCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "DeleteCertificateAuthority", {}).n("ACMPCAClient", "DeleteCertificateAuthorityCommand").f(void 0, void 0).ser(se_DeleteCertificateAuthorityCommand).de(de_DeleteCertificateAuthorityCommand).build() {
-  static {
-    __name(this, "DeleteCertificateAuthorityCommand");
-  }
+const de_CertificateAuthorities = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_CertificateAuthority(entry);
+    });
+    return retVal;
+};
+const de_CertificateAuthority = (output, context) => {
+    return smithyClient.take(output, {
+        Arn: smithyClient.expectString,
+        CertificateAuthorityConfiguration: smithyClient._json,
+        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        FailureReason: smithyClient.expectString,
+        KeyStorageSecurityStandard: smithyClient.expectString,
+        LastStateChangeAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        NotAfter: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        NotBefore: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        OwnerAccount: smithyClient.expectString,
+        RestorableUntil: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        RevocationConfiguration: smithyClient._json,
+        Serial: smithyClient.expectString,
+        Status: smithyClient.expectString,
+        Type: smithyClient.expectString,
+        UsageMode: smithyClient.expectString,
+    });
 };
-// src/commands/DeletePermissionCommand.ts
-var DeletePermissionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "DeletePermission", {}).n("ACMPCAClient", "DeletePermissionCommand").f(void 0, void 0).ser(se_DeletePermissionCommand).de(de_DeletePermissionCommand).build() {
-  static {
-    __name(this, "DeletePermissionCommand");
-  }
+const de_DescribeCertificateAuthorityAuditReportResponse = (output, context) => {
+    return smithyClient.take(output, {
+        AuditReportStatus: smithyClient.expectString,
+        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        S3BucketName: smithyClient.expectString,
+        S3Key: smithyClient.expectString,
+    });
 };
-// src/commands/DeletePolicyCommand.ts
-var DeletePolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "DeletePolicy", {}).n("ACMPCAClient", "DeletePolicyCommand").f(void 0, void 0).ser(se_DeletePolicyCommand).de(de_DeletePolicyCommand).build() {
-  static {
-    __name(this, "DeletePolicyCommand");
-  }
+const de_DescribeCertificateAuthorityResponse = (output, context) => {
+    return smithyClient.take(output, {
+        CertificateAuthority: (_) => de_CertificateAuthority(_),
+    });
 };
-// src/commands/DescribeCertificateAuthorityAuditReportCommand.ts
-var DescribeCertificateAuthorityAuditReportCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "DescribeCertificateAuthorityAuditReport", {}).n("ACMPCAClient", "DescribeCertificateAuthorityAuditReportCommand").f(void 0, void 0).ser(se_DescribeCertificateAuthorityAuditReportCommand).de(de_DescribeCertificateAuthorityAuditReportCommand).build() {
-  static {
-    __name(this, "DescribeCertificateAuthorityAuditReportCommand");
-  }
+const de_ListCertificateAuthoritiesResponse = (output, context) => {
+    return smithyClient.take(output, {
+        CertificateAuthorities: (_) => de_CertificateAuthorities(_),
+        NextToken: smithyClient.expectString,
+    });
 };
-// src/commands/DescribeCertificateAuthorityCommand.ts
-var DescribeCertificateAuthorityCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "DescribeCertificateAuthority", {}).n("ACMPCAClient", "DescribeCertificateAuthorityCommand").f(void 0, void 0).ser(se_DescribeCertificateAuthorityCommand).de(de_DescribeCertificateAuthorityCommand).build() {
-  static {
-    __name(this, "DescribeCertificateAuthorityCommand");
-  }
+const de_ListPermissionsResponse = (output, context) => {
+    return smithyClient.take(output, {
+        NextToken: smithyClient.expectString,
+        Permissions: (_) => de_PermissionList(_),
+    });
 };
-// src/commands/GetCertificateAuthorityCertificateCommand.ts
-var GetCertificateAuthorityCertificateCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "GetCertificateAuthorityCertificate", {}).n("ACMPCAClient", "GetCertificateAuthorityCertificateCommand").f(void 0, void 0).ser(se_GetCertificateAuthorityCertificateCommand).de(de_GetCertificateAuthorityCertificateCommand).build() {
-  static {
-    __name(this, "GetCertificateAuthorityCertificateCommand");
-  }
+const de_Permission = (output, context) => {
+    return smithyClient.take(output, {
+        Actions: smithyClient._json,
+        CertificateAuthorityArn: smithyClient.expectString,
+        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        Policy: smithyClient.expectString,
+        Principal: smithyClient.expectString,
+        SourceAccount: smithyClient.expectString,
+    });
 };
-// src/commands/GetCertificateAuthorityCsrCommand.ts
-var GetCertificateAuthorityCsrCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "GetCertificateAuthorityCsr", {}).n("ACMPCAClient", "GetCertificateAuthorityCsrCommand").f(void 0, void 0).ser(se_GetCertificateAuthorityCsrCommand).de(de_GetCertificateAuthorityCsrCommand).build() {
-  static {
-    __name(this, "GetCertificateAuthorityCsrCommand");
-  }
+const de_PermissionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Permission(entry);
+    });
+    return retVal;
 };
-// src/commands/GetCertificateCommand.ts
-var GetCertificateCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "GetCertificate", {}).n("ACMPCAClient", "GetCertificateCommand").f(void 0, void 0).ser(se_GetCertificateCommand).de(de_GetCertificateCommand).build() {
-  static {
-    __name(this, "GetCertificateCommand");
-  }
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const throwDefaultError = smithyClient.withBaseException(ACMPCAServiceException);
+const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const contents = {
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+        headers,
+    };
+    if (body !== undefined) {
+        contents.body = body;
+    }
+    return new protocolHttp.HttpRequest(contents);
 };
+function sharedHeaders(operation) {
+    return {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": `ACMPrivateCA.${operation}`,
+    };
+}
-// src/commands/GetPolicyCommand.ts
+class CreateCertificateAuthorityAuditReportCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "CreateCertificateAuthorityAuditReport", {})
+    .n("ACMPCAClient", "CreateCertificateAuthorityAuditReportCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateCertificateAuthorityAuditReportCommand)
+    .de(de_CreateCertificateAuthorityAuditReportCommand)
+    .build() {
+}
+class CreateCertificateAuthorityCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "CreateCertificateAuthority", {})
+    .n("ACMPCAClient", "CreateCertificateAuthorityCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateCertificateAuthorityCommand)
+    .de(de_CreateCertificateAuthorityCommand)
+    .build() {
+}
+class CreatePermissionCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "CreatePermission", {})
+    .n("ACMPCAClient", "CreatePermissionCommand")
+    .f(void 0, void 0)
+    .ser(se_CreatePermissionCommand)
+    .de(de_CreatePermissionCommand)
+    .build() {
+}
-var GetPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "GetPolicy", {}).n("ACMPCAClient", "GetPolicyCommand").f(void 0, void 0).ser(se_GetPolicyCommand).de(de_GetPolicyCommand).build() {
-  static {
-    __name(this, "GetPolicyCommand");
-  }
-};
+class DeleteCertificateAuthorityCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "DeleteCertificateAuthority", {})
+    .n("ACMPCAClient", "DeleteCertificateAuthorityCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteCertificateAuthorityCommand)
+    .de(de_DeleteCertificateAuthorityCommand)
+    .build() {
+}
-// src/commands/ImportCertificateAuthorityCertificateCommand.ts
+class DeletePermissionCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "DeletePermission", {})
+    .n("ACMPCAClient", "DeletePermissionCommand")
+    .f(void 0, void 0)
+    .ser(se_DeletePermissionCommand)
+    .de(de_DeletePermissionCommand)
+    .build() {
+}
+class DeletePolicyCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "DeletePolicy", {})
+    .n("ACMPCAClient", "DeletePolicyCommand")
+    .f(void 0, void 0)
+    .ser(se_DeletePolicyCommand)
+    .de(de_DeletePolicyCommand)
+    .build() {
+}
+class DescribeCertificateAuthorityAuditReportCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "DescribeCertificateAuthorityAuditReport", {})
+    .n("ACMPCAClient", "DescribeCertificateAuthorityAuditReportCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeCertificateAuthorityAuditReportCommand)
+    .de(de_DescribeCertificateAuthorityAuditReportCommand)
+    .build() {
+}
-var ImportCertificateAuthorityCertificateCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "ImportCertificateAuthorityCertificate", {}).n("ACMPCAClient", "ImportCertificateAuthorityCertificateCommand").f(void 0, void 0).ser(se_ImportCertificateAuthorityCertificateCommand).de(de_ImportCertificateAuthorityCertificateCommand).build() {
-  static {
-    __name(this, "ImportCertificateAuthorityCertificateCommand");
-  }
-};
+class DescribeCertificateAuthorityCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "DescribeCertificateAuthority", {})
+    .n("ACMPCAClient", "DescribeCertificateAuthorityCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeCertificateAuthorityCommand)
+    .de(de_DescribeCertificateAuthorityCommand)
+    .build() {
+}
-// src/commands/IssueCertificateCommand.ts
+class GetCertificateAuthorityCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "GetCertificateAuthorityCertificate", {})
+    .n("ACMPCAClient", "GetCertificateAuthorityCertificateCommand")
+    .f(void 0, void 0)
+    .ser(se_GetCertificateAuthorityCertificateCommand)
+    .de(de_GetCertificateAuthorityCertificateCommand)
+    .build() {
+}
+class GetCertificateAuthorityCsrCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "GetCertificateAuthorityCsr", {})
+    .n("ACMPCAClient", "GetCertificateAuthorityCsrCommand")
+    .f(void 0, void 0)
+    .ser(se_GetCertificateAuthorityCsrCommand)
+    .de(de_GetCertificateAuthorityCsrCommand)
+    .build() {
+}
+class GetCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "GetCertificate", {})
+    .n("ACMPCAClient", "GetCertificateCommand")
+    .f(void 0, void 0)
+    .ser(se_GetCertificateCommand)
+    .de(de_GetCertificateCommand)
+    .build() {
+}
-var IssueCertificateCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "IssueCertificate", {}).n("ACMPCAClient", "IssueCertificateCommand").f(void 0, void 0).ser(se_IssueCertificateCommand).de(de_IssueCertificateCommand).build() {
-  static {
-    __name(this, "IssueCertificateCommand");
-  }
-};
+class GetPolicyCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "GetPolicy", {})
+    .n("ACMPCAClient", "GetPolicyCommand")
+    .f(void 0, void 0)
+    .ser(se_GetPolicyCommand)
+    .de(de_GetPolicyCommand)
+    .build() {
+}
-// src/commands/ListCertificateAuthoritiesCommand.ts
+class ImportCertificateAuthorityCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "ImportCertificateAuthorityCertificate", {})
+    .n("ACMPCAClient", "ImportCertificateAuthorityCertificateCommand")
+    .f(void 0, void 0)
+    .ser(se_ImportCertificateAuthorityCertificateCommand)
+    .de(de_ImportCertificateAuthorityCertificateCommand)
+    .build() {
+}
+class IssueCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "IssueCertificate", {})
+    .n("ACMPCAClient", "IssueCertificateCommand")
+    .f(void 0, void 0)
+    .ser(se_IssueCertificateCommand)
+    .de(de_IssueCertificateCommand)
+    .build() {
+}
+class ListCertificateAuthoritiesCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "ListCertificateAuthorities", {})
+    .n("ACMPCAClient", "ListCertificateAuthoritiesCommand")
+    .f(void 0, void 0)
+    .ser(se_ListCertificateAuthoritiesCommand)
+    .de(de_ListCertificateAuthoritiesCommand)
+    .build() {
+}
-var ListCertificateAuthoritiesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "ListCertificateAuthorities", {}).n("ACMPCAClient", "ListCertificateAuthoritiesCommand").f(void 0, void 0).ser(se_ListCertificateAuthoritiesCommand).de(de_ListCertificateAuthoritiesCommand).build() {
-  static {
-    __name(this, "ListCertificateAuthoritiesCommand");
-  }
-};
+class ListPermissionsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "ListPermissions", {})
+    .n("ACMPCAClient", "ListPermissionsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListPermissionsCommand)
+    .de(de_ListPermissionsCommand)
+    .build() {
+}
-// src/commands/ListPermissionsCommand.ts
+class ListTagsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "ListTags", {})
+    .n("ACMPCAClient", "ListTagsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListTagsCommand)
+    .de(de_ListTagsCommand)
+    .build() {
+}
+class PutPolicyCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "PutPolicy", {})
+    .n("ACMPCAClient", "PutPolicyCommand")
+    .f(void 0, void 0)
+    .ser(se_PutPolicyCommand)
+    .de(de_PutPolicyCommand)
+    .build() {
+}
+class RestoreCertificateAuthorityCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "RestoreCertificateAuthority", {})
+    .n("ACMPCAClient", "RestoreCertificateAuthorityCommand")
+    .f(void 0, void 0)
+    .ser(se_RestoreCertificateAuthorityCommand)
+    .de(de_RestoreCertificateAuthorityCommand)
+    .build() {
+}
-var ListPermissionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "ListPermissions", {}).n("ACMPCAClient", "ListPermissionsCommand").f(void 0, void 0).ser(se_ListPermissionsCommand).de(de_ListPermissionsCommand).build() {
-  static {
-    __name(this, "ListPermissionsCommand");
-  }
-};
+class RevokeCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "RevokeCertificate", {})
+    .n("ACMPCAClient", "RevokeCertificateCommand")
+    .f(void 0, void 0)
+    .ser(se_RevokeCertificateCommand)
+    .de(de_RevokeCertificateCommand)
+    .build() {
+}
-// src/commands/ListTagsCommand.ts
+class TagCertificateAuthorityCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "TagCertificateAuthority", {})
+    .n("ACMPCAClient", "TagCertificateAuthorityCommand")
+    .f(void 0, void 0)
+    .ser(se_TagCertificateAuthorityCommand)
+    .de(de_TagCertificateAuthorityCommand)
+    .build() {
+}
+class UntagCertificateAuthorityCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "UntagCertificateAuthority", {})
+    .n("ACMPCAClient", "UntagCertificateAuthorityCommand")
+    .f(void 0, void 0)
+    .ser(se_UntagCertificateAuthorityCommand)
+    .de(de_UntagCertificateAuthorityCommand)
+    .build() {
+}
+class UpdateCertificateAuthorityCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ACMPrivateCA", "UpdateCertificateAuthority", {})
+    .n("ACMPCAClient", "UpdateCertificateAuthorityCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateCertificateAuthorityCommand)
+    .de(de_UpdateCertificateAuthorityCommand)
+    .build() {
+}
-var ListTagsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "ListTags", {}).n("ACMPCAClient", "ListTagsCommand").f(void 0, void 0).ser(se_ListTagsCommand).de(de_ListTagsCommand).build() {
-  static {
-    __name(this, "ListTagsCommand");
-  }
-};
+const commands = {
+    CreateCertificateAuthorityCommand,
+    CreateCertificateAuthorityAuditReportCommand,
+    CreatePermissionCommand,
+    DeleteCertificateAuthorityCommand,
+    DeletePermissionCommand,
+    DeletePolicyCommand,
+    DescribeCertificateAuthorityCommand,
+    DescribeCertificateAuthorityAuditReportCommand,
+    GetCertificateCommand,
+    GetCertificateAuthorityCertificateCommand,
+    GetCertificateAuthorityCsrCommand,
+    GetPolicyCommand,
+    ImportCertificateAuthorityCertificateCommand,
+    IssueCertificateCommand,
+    ListCertificateAuthoritiesCommand,
+    ListPermissionsCommand,
+    ListTagsCommand,
+    PutPolicyCommand,
+    RestoreCertificateAuthorityCommand,
+    RevokeCertificateCommand,
+    TagCertificateAuthorityCommand,
+    UntagCertificateAuthorityCommand,
+    UpdateCertificateAuthorityCommand,
+};
+class ACMPCA extends ACMPCAClient {
+}
+smithyClient.createAggregatedClient(commands, ACMPCA);
-// src/commands/PutPolicyCommand.ts
+const paginateListCertificateAuthorities = core.createPaginator(ACMPCAClient, ListCertificateAuthoritiesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListPermissions = core.createPaginator(ACMPCAClient, ListPermissionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTags = core.createPaginator(ACMPCAClient, ListTagsCommand, "NextToken", "NextToken", "MaxResults");
-var PutPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "PutPolicy", {}).n("ACMPCAClient", "PutPolicyCommand").f(void 0, void 0).ser(se_PutPolicyCommand).de(de_PutPolicyCommand).build() {
-  static {
-    __name(this, "PutPolicyCommand");
-  }
+const checkState$2 = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeCertificateAuthorityAuditReportCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.AuditReportStatus;
+            };
+            if (returnComparator() === "SUCCESS") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.AuditReportStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "AccessDeniedException") {
+            return { state: utilWaiter.WaiterState.FAILURE, reason };
+        }
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-// src/commands/RestoreCertificateAuthorityCommand.ts
-var RestoreCertificateAuthorityCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "RestoreCertificateAuthority", {}).n("ACMPCAClient", "RestoreCertificateAuthorityCommand").f(void 0, void 0).ser(se_RestoreCertificateAuthorityCommand).de(de_RestoreCertificateAuthorityCommand).build() {
-  static {
-    __name(this, "RestoreCertificateAuthorityCommand");
-  }
+const waitForAuditReportCreated = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 180 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
-// src/commands/RevokeCertificateCommand.ts
-var RevokeCertificateCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "RevokeCertificate", {}).n("ACMPCAClient", "RevokeCertificateCommand").f(void 0, void 0).ser(se_RevokeCertificateCommand).de(de_RevokeCertificateCommand).build() {
-  static {
-    __name(this, "RevokeCertificateCommand");
-  }
+const waitUntilAuditReportCreated = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 180 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return utilWaiter.checkExceptions(result);
 };
-// src/commands/TagCertificateAuthorityCommand.ts
-var TagCertificateAuthorityCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "TagCertificateAuthority", {}).n("ACMPCAClient", "TagCertificateAuthorityCommand").f(void 0, void 0).ser(se_TagCertificateAuthorityCommand).de(de_TagCertificateAuthorityCommand).build() {
-  static {
-    __name(this, "TagCertificateAuthorityCommand");
-  }
+const checkState$1 = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetCertificateAuthorityCsrCommand(input));
+        reason = result;
+        return { state: utilWaiter.WaiterState.SUCCESS, reason };
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "RequestInProgressException") {
+            return { state: utilWaiter.WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "AccessDeniedException") {
+            return { state: utilWaiter.WaiterState.FAILURE, reason };
+        }
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-// src/commands/UntagCertificateAuthorityCommand.ts
-var UntagCertificateAuthorityCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "UntagCertificateAuthority", {}).n("ACMPCAClient", "UntagCertificateAuthorityCommand").f(void 0, void 0).ser(se_UntagCertificateAuthorityCommand).de(de_UntagCertificateAuthorityCommand).build() {
-  static {
-    __name(this, "UntagCertificateAuthorityCommand");
-  }
+const waitForCertificateAuthorityCSRCreated = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 180 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
-// src/commands/UpdateCertificateAuthorityCommand.ts
-var UpdateCertificateAuthorityCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("ACMPrivateCA", "UpdateCertificateAuthority", {}).n("ACMPCAClient", "UpdateCertificateAuthorityCommand").f(void 0, void 0).ser(se_UpdateCertificateAuthorityCommand).de(de_UpdateCertificateAuthorityCommand).build() {
-  static {
-    __name(this, "UpdateCertificateAuthorityCommand");
-  }
+const waitUntilCertificateAuthorityCSRCreated = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 180 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return utilWaiter.checkExceptions(result);
 };
-// 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 extends ACMPCAClient {
-  static {
-    __name(this, "ACMPCA");
-  }
-};
-(0, import_smithy_client.createAggregatedClient)(commands, ACMPCA);
-// src/pagination/ListCertificateAuthoritiesPaginator.ts
-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) {
-    }
+const checkState = async (client, input) => {
+    let reason;
     try {
-      const returnComparator = /* @__PURE__ */ __name(() => {
-        return result.AuditReportStatus;
-      }, "returnComparator");
-      if (returnComparator() === "FAILED") {
-        return { state: import_util_waiter.WaiterState.FAILURE, reason };
-      }
-    } catch (e) {
+        const result = await client.send(new GetCertificateCommand(input));
+        reason = result;
+        return { state: utilWaiter.WaiterState.SUCCESS, reason };
     }
-  } catch (exception) {
-    reason = exception;
-    if (exception.name && exception.name == "AccessDeniedException") {
-      return { state: import_util_waiter.WaiterState.FAILURE, reason };
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "RequestInProgressException") {
+            return { state: utilWaiter.WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "AccessDeniedException") {
+            return { state: utilWaiter.WaiterState.FAILURE, reason };
+        }
     }
-  }
-  return { state: import_util_waiter.WaiterState.RETRY, reason };
-}, "checkState");
-var waitForAuditReportCreated = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 3, maxDelay: 180 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-}, "waitForAuditReportCreated");
-var waitUntilAuditReportCreated = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 3, maxDelay: 180 };
-  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 };
-    }
-    if (exception.name && exception.name == "AccessDeniedException") {
-      return { state: import_util_waiter.WaiterState.FAILURE, reason };
-    }
-  }
-  return { state: import_util_waiter.WaiterState.RETRY, reason };
-}, "checkState");
-var waitForCertificateAuthorityCSRCreated = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 3, maxDelay: 180 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
-}, "waitForCertificateAuthorityCSRCreated");
-var waitUntilCertificateAuthorityCSRCreated = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 3, maxDelay: 180 };
-  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 };
-    }
-    if (exception.name && exception.name == "AccessDeniedException") {
-      return { state: import_util_waiter.WaiterState.FAILURE, reason };
-    }
-  }
-  return { state: import_util_waiter.WaiterState.RETRY, reason };
-}, "checkState");
-var waitForCertificateIssued = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 1, maxDelay: 60 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
-}, "waitForCertificateIssued");
-var waitUntilCertificateIssued = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 1, maxDelay: 60 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
-  return (0, import_util_waiter.checkExceptions)(result);
-}, "waitUntilCertificateIssued");
-// Annotate the CommonJS export names for ESM import in node:
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForCertificateIssued = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 60 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+const waitUntilCertificateIssued = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 60 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return utilWaiter.checkExceptions(result);
+};
-0 && (module.exports = {
-  ACMPCAServiceException,
-  __Client,
-  ACMPCAClient,
-  ACMPCA,
-  $Command,
-  CreateCertificateAuthorityAuditReportCommand,
-  CreateCertificateAuthorityCommand,
-  CreatePermissionCommand,
-  DeleteCertificateAuthorityCommand,
-  DeletePermissionCommand,
-  DeletePolicyCommand,
-  DescribeCertificateAuthorityAuditReportCommand,
-  DescribeCertificateAuthorityCommand,
-  GetCertificateAuthorityCertificateCommand,
-  GetCertificateAuthorityCsrCommand,
-  GetCertificateCommand,
-  GetPolicyCommand,
-  ImportCertificateAuthorityCertificateCommand,
-  IssueCertificateCommand,
-  ListCertificateAuthoritiesCommand,
-  ListPermissionsCommand,
-  ListTagsCommand,
-  PutPolicyCommand,
-  RestoreCertificateAuthorityCommand,
-  RevokeCertificateCommand,
-  TagCertificateAuthorityCommand,
-  UntagCertificateAuthorityCommand,
-  UpdateCertificateAuthorityCommand,
-  paginateListCertificateAuthorities,
-  paginateListPermissions,
-  paginateListTags,
-  waitForAuditReportCreated,
-  waitUntilAuditReportCreated,
-  waitForCertificateAuthorityCSRCreated,
-  waitUntilCertificateAuthorityCSRCreated,
-  waitForCertificateIssued,
-  waitUntilCertificateIssued,
-  AccessMethodType,
-  KeyAlgorithm,
-  SigningAlgorithm,
-  CertificateAuthorityType,
-  KeyStorageSecurityStandard,
-  CrlType,
-  S3ObjectAcl,
-  CertificateAuthorityUsageMode,
-  InvalidArgsException,
-  InvalidPolicyException,
-  InvalidTagException,
-  LimitExceededException,
-  AuditReportResponseFormat,
-  InvalidArnException,
-  InvalidStateException,
-  RequestFailedException,
-  RequestInProgressException,
-  ResourceNotFoundException,
-  ActionType,
-  PermissionAlreadyExistsException,
-  ConcurrentModificationException,
-  LockoutPreventedException,
-  FailureReason,
-  CertificateAuthorityStatus,
-  AuditReportStatus,
-  CertificateMismatchException,
-  InvalidRequestException,
-  MalformedCertificateException,
-  PolicyQualifierId,
-  ExtendedKeyUsageType,
-  ValidityPeriodType,
-  MalformedCSRException,
-  InvalidNextTokenException,
-  ResourceOwner,
-  RequestAlreadyProcessedException,
-  RevocationReason,
-  TooManyTagsException
+Object.defineProperty(exports, "$Command", {
+    enumerable: true,
+    get: function () { return smithyClient.Command; }
 });
+Object.defineProperty(exports, "__Client", {
+    enumerable: true,
+    get: function () { return smithyClient.Client; }
+});
+exports.ACMPCA = ACMPCA;
+exports.ACMPCAClient = ACMPCAClient;
+exports.ACMPCAServiceException = ACMPCAServiceException;
+exports.AccessMethodType = AccessMethodType;
+exports.ActionType = ActionType;
+exports.AuditReportResponseFormat = AuditReportResponseFormat;
+exports.AuditReportStatus = AuditReportStatus;
+exports.CertificateAuthorityStatus = CertificateAuthorityStatus;
+exports.CertificateAuthorityType = CertificateAuthorityType;
+exports.CertificateAuthorityUsageMode = CertificateAuthorityUsageMode;
+exports.CertificateMismatchException = CertificateMismatchException;
+exports.ConcurrentModificationException = ConcurrentModificationException;
+exports.CreateCertificateAuthorityAuditReportCommand = CreateCertificateAuthorityAuditReportCommand;
+exports.CreateCertificateAuthorityCommand = CreateCertificateAuthorityCommand;
+exports.CreatePermissionCommand = CreatePermissionCommand;
+exports.CrlType = CrlType;
+exports.DeleteCertificateAuthorityCommand = DeleteCertificateAuthorityCommand;
+exports.DeletePermissionCommand = DeletePermissionCommand;
+exports.DeletePolicyCommand = DeletePolicyCommand;
+exports.DescribeCertificateAuthorityAuditReportCommand = DescribeCertificateAuthorityAuditReportCommand;
+exports.DescribeCertificateAuthorityCommand = DescribeCertificateAuthorityCommand;
+exports.ExtendedKeyUsageType = ExtendedKeyUsageType;
+exports.FailureReason = FailureReason;
+exports.GetCertificateAuthorityCertificateCommand = GetCertificateAuthorityCertificateCommand;
+exports.GetCertificateAuthorityCsrCommand = GetCertificateAuthorityCsrCommand;
+exports.GetCertificateCommand = GetCertificateCommand;
+exports.GetPolicyCommand = GetPolicyCommand;
+exports.ImportCertificateAuthorityCertificateCommand = ImportCertificateAuthorityCertificateCommand;
+exports.InvalidArgsException = InvalidArgsException;
+exports.InvalidArnException = InvalidArnException;
+exports.InvalidNextTokenException = InvalidNextTokenException;
+exports.InvalidPolicyException = InvalidPolicyException;
+exports.InvalidRequestException = InvalidRequestException;
+exports.InvalidStateException = InvalidStateException;
+exports.InvalidTagException = InvalidTagException;
+exports.IssueCertificateCommand = IssueCertificateCommand;
+exports.KeyAlgorithm = KeyAlgorithm;
+exports.KeyStorageSecurityStandard = KeyStorageSecurityStandard;
+exports.LimitExceededException = LimitExceededException;
+exports.ListCertificateAuthoritiesCommand = ListCertificateAuthoritiesCommand;
+exports.ListPermissionsCommand = ListPermissionsCommand;
+exports.ListTagsCommand = ListTagsCommand;
+exports.LockoutPreventedException = LockoutPreventedException;
+exports.MalformedCSRException = MalformedCSRException;
+exports.MalformedCertificateException = MalformedCertificateException;
+exports.PermissionAlreadyExistsException = PermissionAlreadyExistsException;
+exports.PolicyQualifierId = PolicyQualifierId;
+exports.PutPolicyCommand = PutPolicyCommand;
+exports.RequestAlreadyProcessedException = RequestAlreadyProcessedException;
+exports.RequestFailedException = RequestFailedException;
+exports.RequestInProgressException = RequestInProgressException;
+exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceOwner = ResourceOwner;
+exports.RestoreCertificateAuthorityCommand = RestoreCertificateAuthorityCommand;
+exports.RevocationReason = RevocationReason;
+exports.RevokeCertificateCommand = RevokeCertificateCommand;
+exports.S3ObjectAcl = S3ObjectAcl;
+exports.SigningAlgorithm = SigningAlgorithm;
+exports.TagCertificateAuthorityCommand = TagCertificateAuthorityCommand;
+exports.TooManyTagsException = TooManyTagsException;
+exports.UntagCertificateAuthorityCommand = UntagCertificateAuthorityCommand;
+exports.UpdateCertificateAuthorityCommand = UpdateCertificateAuthorityCommand;
+exports.ValidityPeriodType = ValidityPeriodType;
+exports.paginateListCertificateAuthorities = paginateListCertificateAuthorities;
+exports.paginateListPermissions = paginateListPermissions;
+exports.paginateListTags = paginateListTags;
+exports.waitForAuditReportCreated = waitForAuditReportCreated;
+exports.waitForCertificateAuthorityCSRCreated = waitForCertificateAuthorityCSRCreated;
+exports.waitForCertificateIssued = waitForCertificateIssued;
+exports.waitUntilAuditReportCreated = waitUntilAuditReportCreated;
+exports.waitUntilCertificateAuthorityCSRCreated = waitUntilCertificateAuthorityCSRCreated;
+exports.waitUntilCertificateIssued = waitUntilCertificateIssued;