@aws-sdk/client-acm 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,13 +1,1999 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ACMServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ACMClient"), exports);
-tslib_1.__exportStar(require("./ACM"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var ACMServiceException_1 = require("./models/ACMServiceException");
-Object.defineProperty(exports, "ACMServiceException", { enumerable: true, get: function () { return ACMServiceException_1.ACMServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ACM: () => ACM,
+  ACMClient: () => ACMClient,
+  ACMServiceException: () => ACMServiceException,
+  AccessDeniedException: () => AccessDeniedException,
+  AddTagsToCertificateCommand: () => AddTagsToCertificateCommand,
+  CertificateStatus: () => CertificateStatus,
+  CertificateTransparencyLoggingPreference: () => CertificateTransparencyLoggingPreference,
+  CertificateType: () => CertificateType,
+  ConflictException: () => ConflictException,
+  DeleteCertificateCommand: () => DeleteCertificateCommand,
+  DescribeCertificateCommand: () => DescribeCertificateCommand,
+  DomainStatus: () => DomainStatus,
+  ExportCertificateCommand: () => ExportCertificateCommand,
+  ExportCertificateRequestFilterSensitiveLog: () => ExportCertificateRequestFilterSensitiveLog,
+  ExportCertificateResponseFilterSensitiveLog: () => ExportCertificateResponseFilterSensitiveLog,
+  ExtendedKeyUsageName: () => ExtendedKeyUsageName,
+  FailureReason: () => FailureReason,
+  GetAccountConfigurationCommand: () => GetAccountConfigurationCommand,
+  GetCertificateCommand: () => GetCertificateCommand,
+  ImportCertificateCommand: () => ImportCertificateCommand,
+  ImportCertificateRequestFilterSensitiveLog: () => ImportCertificateRequestFilterSensitiveLog,
+  InvalidArgsException: () => InvalidArgsException,
+  InvalidArnException: () => InvalidArnException,
+  InvalidDomainValidationOptionsException: () => InvalidDomainValidationOptionsException,
+  InvalidParameterException: () => InvalidParameterException,
+  InvalidStateException: () => InvalidStateException,
+  InvalidTagException: () => InvalidTagException,
+  KeyAlgorithm: () => KeyAlgorithm,
+  KeyUsageName: () => KeyUsageName,
+  LimitExceededException: () => LimitExceededException,
+  ListCertificatesCommand: () => ListCertificatesCommand,
+  ListTagsForCertificateCommand: () => ListTagsForCertificateCommand,
+  PutAccountConfigurationCommand: () => PutAccountConfigurationCommand,
+  RecordType: () => RecordType,
+  RemoveTagsFromCertificateCommand: () => RemoveTagsFromCertificateCommand,
+  RenewCertificateCommand: () => RenewCertificateCommand,
+  RenewalEligibility: () => RenewalEligibility,
+  RenewalStatus: () => RenewalStatus,
+  RequestCertificateCommand: () => RequestCertificateCommand,
+  RequestInProgressException: () => RequestInProgressException,
+  ResendValidationEmailCommand: () => ResendValidationEmailCommand,
+  ResourceInUseException: () => ResourceInUseException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  RevocationReason: () => RevocationReason,
+  SortBy: () => SortBy,
+  SortOrder: () => SortOrder,
+  TagPolicyException: () => TagPolicyException,
+  ThrottlingException: () => ThrottlingException,
+  TooManyTagsException: () => TooManyTagsException,
+  UpdateCertificateOptionsCommand: () => UpdateCertificateOptionsCommand,
+  ValidationException: () => ValidationException,
+  ValidationMethod: () => ValidationMethod,
+  __Client: () => import_smithy_client.Client,
+  paginateListCertificates: () => paginateListCertificates,
+  waitForCertificateValidated: () => waitForCertificateValidated,
+  waitUntilCertificateValidated: () => waitUntilCertificateValidated
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ACMClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "acm"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ACMClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/ACMClient.ts
+var _ACMClient = class _ACMClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_ACMClient, "ACMClient");
+var ACMClient = _ACMClient;
+
+// src/ACM.ts
+
+
+// src/commands/AddTagsToCertificateCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/ACMServiceException.ts
+
+var _ACMServiceException = class _ACMServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ACMServiceException.prototype);
+  }
+};
+__name(_ACMServiceException, "ACMServiceException");
+var ACMServiceException = _ACMServiceException;
+
+// src/models/models_0.ts
+
+var _AccessDeniedException = class _AccessDeniedException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var _InvalidArnException = class _InvalidArnException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidArnException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidArnException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidArnException.prototype);
+  }
+};
+__name(_InvalidArnException, "InvalidArnException");
+var InvalidArnException = _InvalidArnException;
+var _InvalidParameterException = class _InvalidParameterException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
+  }
+};
+__name(_InvalidParameterException, "InvalidParameterException");
+var InvalidParameterException = _InvalidParameterException;
+var _InvalidTagException = class _InvalidTagException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidTagException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidTagException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidTagException.prototype);
+  }
+};
+__name(_InvalidTagException, "InvalidTagException");
+var InvalidTagException = _InvalidTagException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _TagPolicyException = class _TagPolicyException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TagPolicyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TagPolicyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TagPolicyException.prototype);
+  }
+};
+__name(_TagPolicyException, "TagPolicyException");
+var TagPolicyException = _TagPolicyException;
+var _ThrottlingException = class _ThrottlingException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _TooManyTagsException = class _TooManyTagsException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+var RecordType = {
+  CNAME: "CNAME"
+};
+var ValidationMethod = {
+  DNS: "DNS",
+  EMAIL: "EMAIL"
+};
+var DomainStatus = {
+  FAILED: "FAILED",
+  PENDING_VALIDATION: "PENDING_VALIDATION",
+  SUCCESS: "SUCCESS"
+};
+var ExtendedKeyUsageName = {
+  ANY: "ANY",
+  CODE_SIGNING: "CODE_SIGNING",
+  CUSTOM: "CUSTOM",
+  EMAIL_PROTECTION: "EMAIL_PROTECTION",
+  IPSEC_END_SYSTEM: "IPSEC_END_SYSTEM",
+  IPSEC_TUNNEL: "IPSEC_TUNNEL",
+  IPSEC_USER: "IPSEC_USER",
+  NONE: "NONE",
+  OCSP_SIGNING: "OCSP_SIGNING",
+  TIME_STAMPING: "TIME_STAMPING",
+  TLS_WEB_CLIENT_AUTHENTICATION: "TLS_WEB_CLIENT_AUTHENTICATION",
+  TLS_WEB_SERVER_AUTHENTICATION: "TLS_WEB_SERVER_AUTHENTICATION"
+};
+var FailureReason = {
+  ADDITIONAL_VERIFICATION_REQUIRED: "ADDITIONAL_VERIFICATION_REQUIRED",
+  CAA_ERROR: "CAA_ERROR",
+  DOMAIN_NOT_ALLOWED: "DOMAIN_NOT_ALLOWED",
+  DOMAIN_VALIDATION_DENIED: "DOMAIN_VALIDATION_DENIED",
+  INVALID_PUBLIC_DOMAIN: "INVALID_PUBLIC_DOMAIN",
+  NO_AVAILABLE_CONTACTS: "NO_AVAILABLE_CONTACTS",
+  OTHER: "OTHER",
+  PCA_ACCESS_DENIED: "PCA_ACCESS_DENIED",
+  PCA_INVALID_ARGS: "PCA_INVALID_ARGS",
+  PCA_INVALID_ARN: "PCA_INVALID_ARN",
+  PCA_INVALID_DURATION: "PCA_INVALID_DURATION",
+  PCA_INVALID_STATE: "PCA_INVALID_STATE",
+  PCA_LIMIT_EXCEEDED: "PCA_LIMIT_EXCEEDED",
+  PCA_NAME_CONSTRAINTS_VALIDATION: "PCA_NAME_CONSTRAINTS_VALIDATION",
+  PCA_REQUEST_FAILED: "PCA_REQUEST_FAILED",
+  PCA_RESOURCE_NOT_FOUND: "PCA_RESOURCE_NOT_FOUND",
+  SLR_NOT_FOUND: "SLR_NOT_FOUND"
+};
+var KeyAlgorithm = {
+  EC_prime256v1: "EC_prime256v1",
+  EC_secp384r1: "EC_secp384r1",
+  EC_secp521r1: "EC_secp521r1",
+  RSA_1024: "RSA_1024",
+  RSA_2048: "RSA_2048",
+  RSA_3072: "RSA_3072",
+  RSA_4096: "RSA_4096"
+};
+var KeyUsageName = {
+  ANY: "ANY",
+  CERTIFICATE_SIGNING: "CERTIFICATE_SIGNING",
+  CRL_SIGNING: "CRL_SIGNING",
+  CUSTOM: "CUSTOM",
+  DATA_ENCIPHERMENT: "DATA_ENCIPHERMENT",
+  DECIPHER_ONLY: "DECIPHER_ONLY",
+  DIGITAL_SIGNATURE: "DIGITAL_SIGNATURE",
+  ENCHIPER_ONLY: "ENCIPHER_ONLY",
+  KEY_AGREEMENT: "KEY_AGREEMENT",
+  KEY_ENCIPHERMENT: "KEY_ENCIPHERMENT",
+  NON_REPUDATION: "NON_REPUDIATION"
+};
+var CertificateTransparencyLoggingPreference = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var RenewalEligibility = {
+  ELIGIBLE: "ELIGIBLE",
+  INELIGIBLE: "INELIGIBLE"
+};
+var RenewalStatus = {
+  FAILED: "FAILED",
+  PENDING_AUTO_RENEWAL: "PENDING_AUTO_RENEWAL",
+  PENDING_VALIDATION: "PENDING_VALIDATION",
+  SUCCESS: "SUCCESS"
+};
+var RevocationReason = {
+  AFFILIATION_CHANGED: "AFFILIATION_CHANGED",
+  A_A_COMPROMISE: "A_A_COMPROMISE",
+  CA_COMPROMISE: "CA_COMPROMISE",
+  CERTIFICATE_HOLD: "CERTIFICATE_HOLD",
+  CESSATION_OF_OPERATION: "CESSATION_OF_OPERATION",
+  KEY_COMPROMISE: "KEY_COMPROMISE",
+  PRIVILEGE_WITHDRAWN: "PRIVILEGE_WITHDRAWN",
+  REMOVE_FROM_CRL: "REMOVE_FROM_CRL",
+  SUPERCEDED: "SUPERCEDED",
+  UNSPECIFIED: "UNSPECIFIED"
+};
+var CertificateStatus = {
+  EXPIRED: "EXPIRED",
+  FAILED: "FAILED",
+  INACTIVE: "INACTIVE",
+  ISSUED: "ISSUED",
+  PENDING_VALIDATION: "PENDING_VALIDATION",
+  REVOKED: "REVOKED",
+  VALIDATION_TIMED_OUT: "VALIDATION_TIMED_OUT"
+};
+var CertificateType = {
+  AMAZON_ISSUED: "AMAZON_ISSUED",
+  IMPORTED: "IMPORTED",
+  PRIVATE: "PRIVATE"
+};
+var _ConflictException = class _ConflictException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _ResourceInUseException = class _ResourceInUseException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceInUseException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceInUseException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceInUseException.prototype);
+  }
+};
+__name(_ResourceInUseException, "ResourceInUseException");
+var ResourceInUseException = _ResourceInUseException;
+var _RequestInProgressException = class _RequestInProgressException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RequestInProgressException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RequestInProgressException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RequestInProgressException.prototype);
+  }
+};
+__name(_RequestInProgressException, "RequestInProgressException");
+var RequestInProgressException = _RequestInProgressException;
+var _LimitExceededException = class _LimitExceededException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _InvalidArgsException = class _InvalidArgsException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidArgsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidArgsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidArgsException.prototype);
+  }
+};
+__name(_InvalidArgsException, "InvalidArgsException");
+var InvalidArgsException = _InvalidArgsException;
+var SortBy = {
+  CREATED_AT: "CREATED_AT"
+};
+var SortOrder = {
+  ASCENDING: "ASCENDING",
+  DESCENDING: "DESCENDING"
+};
+var _ValidationException = class _ValidationException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _InvalidDomainValidationOptionsException = class _InvalidDomainValidationOptionsException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidDomainValidationOptionsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidDomainValidationOptionsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidDomainValidationOptionsException.prototype);
+  }
+};
+__name(_InvalidDomainValidationOptionsException, "InvalidDomainValidationOptionsException");
+var InvalidDomainValidationOptionsException = _InvalidDomainValidationOptionsException;
+var _InvalidStateException = class _InvalidStateException extends ACMServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidStateException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidStateException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidStateException.prototype);
+  }
+};
+__name(_InvalidStateException, "InvalidStateException");
+var InvalidStateException = _InvalidStateException;
+var ExportCertificateRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Passphrase && { Passphrase: import_smithy_client.SENSITIVE_STRING }
+}), "ExportCertificateRequestFilterSensitiveLog");
+var ExportCertificateResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrivateKey && { PrivateKey: import_smithy_client.SENSITIVE_STRING }
+}), "ExportCertificateResponseFilterSensitiveLog");
+var ImportCertificateRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.PrivateKey && { PrivateKey: import_smithy_client.SENSITIVE_STRING }
+}), "ImportCertificateRequestFilterSensitiveLog");
+
+// src/protocols/Aws_json1_1.ts
+var se_AddTagsToCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddTagsToCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddTagsToCertificateCommand");
+var se_DeleteCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteCertificateCommand");
+var se_DescribeCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCertificateCommand");
+var se_ExportCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ExportCertificate");
+  let body;
+  body = JSON.stringify(se_ExportCertificateRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ExportCertificateCommand");
+var se_GetAccountConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetAccountConfiguration");
+  const body = "{}";
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetAccountConfigurationCommand");
+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_ImportCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ImportCertificate");
+  let body;
+  body = JSON.stringify(se_ImportCertificateRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ImportCertificateCommand");
+var se_ListCertificatesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListCertificates");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListCertificatesCommand");
+var se_ListTagsForCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTagsForCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsForCertificateCommand");
+var se_PutAccountConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutAccountConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutAccountConfigurationCommand");
+var se_RemoveTagsFromCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RemoveTagsFromCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RemoveTagsFromCertificateCommand");
+var se_RenewCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RenewCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RenewCertificateCommand");
+var se_RequestCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RequestCertificate");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RequestCertificateCommand");
+var se_ResendValidationEmailCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ResendValidationEmail");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ResendValidationEmailCommand");
+var se_UpdateCertificateOptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateCertificateOptions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateCertificateOptionsCommand");
+var de_AddTagsToCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddTagsToCertificateCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_AddTagsToCertificateCommand");
+var de_AddTagsToCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.acm#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidTagException":
+    case "com.amazonaws.acm#InvalidTagException":
+      throw await de_InvalidTagExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TagPolicyException":
+    case "com.amazonaws.acm#TagPolicyException":
+      throw await de_TagPolicyExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.acm#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.acm#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddTagsToCertificateCommandError");
+var de_DeleteCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteCertificateCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteCertificateCommand");
+var de_DeleteCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.acm#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.acm#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.acm#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.acm#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteCertificateCommandError");
+var de_DescribeCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeCertificateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeCertificateResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCertificateCommand");
+var de_DescribeCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCertificateCommandError");
+var de_ExportCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ExportCertificateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ExportCertificateCommand");
+var de_ExportCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "RequestInProgressException":
+    case "com.amazonaws.acm#RequestInProgressException":
+      throw await de_RequestInProgressExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ExportCertificateCommandError");
+var de_GetAccountConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAccountConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAccountConfigurationCommand");
+var de_GetAccountConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.acm#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.acm#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAccountConfigurationCommandError");
+var de_GetCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetCertificateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetCertificateCommand");
+var de_GetCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "RequestInProgressException":
+    case "com.amazonaws.acm#RequestInProgressException":
+      throw await de_RequestInProgressExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCertificateCommandError");
+var de_ImportCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ImportCertificateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ImportCertificateCommand");
+var de_ImportCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.acm#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidTagException":
+    case "com.amazonaws.acm#InvalidTagException":
+      throw await de_InvalidTagExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.acm#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TagPolicyException":
+    case "com.amazonaws.acm#TagPolicyException":
+      throw await de_TagPolicyExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.acm#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ImportCertificateCommandError");
+var de_ListCertificatesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListCertificatesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListCertificatesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListCertificatesCommand");
+var de_ListCertificatesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArgsException":
+    case "com.amazonaws.acm#InvalidArgsException":
+      throw await de_InvalidArgsExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.acm#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCertificatesCommandError");
+var de_ListTagsForCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForCertificateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForCertificateCommand");
+var de_ListTagsForCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForCertificateCommandError");
+var de_PutAccountConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutAccountConfigurationCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_PutAccountConfigurationCommand");
+var de_PutAccountConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.acm#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.acm#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.acm#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.acm#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutAccountConfigurationCommandError");
+var de_RemoveTagsFromCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RemoveTagsFromCertificateCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RemoveTagsFromCertificateCommand");
+var de_RemoveTagsFromCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.acm#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidTagException":
+    case "com.amazonaws.acm#InvalidTagException":
+      throw await de_InvalidTagExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TagPolicyException":
+    case "com.amazonaws.acm#TagPolicyException":
+      throw await de_TagPolicyExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.acm#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RemoveTagsFromCertificateCommandError");
+var de_RenewCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RenewCertificateCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RenewCertificateCommand");
+var de_RenewCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RenewCertificateCommandError");
+var de_RequestCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RequestCertificateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RequestCertificateCommand");
+var de_RequestCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidDomainValidationOptionsException":
+    case "com.amazonaws.acm#InvalidDomainValidationOptionsException":
+      throw await de_InvalidDomainValidationOptionsExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.acm#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidTagException":
+    case "com.amazonaws.acm#InvalidTagException":
+      throw await de_InvalidTagExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.acm#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "TagPolicyException":
+    case "com.amazonaws.acm#TagPolicyException":
+      throw await de_TagPolicyExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.acm#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RequestCertificateCommandError");
+var de_ResendValidationEmailCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ResendValidationEmailCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_ResendValidationEmailCommand");
+var de_ResendValidationEmailCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidDomainValidationOptionsException":
+    case "com.amazonaws.acm#InvalidDomainValidationOptionsException":
+      throw await de_InvalidDomainValidationOptionsExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acm#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ResendValidationEmailCommandError");
+var de_UpdateCertificateOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateCertificateOptionsCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_UpdateCertificateOptionsCommand");
+var de_UpdateCertificateOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArnException":
+    case "com.amazonaws.acm#InvalidArnException":
+      throw await de_InvalidArnExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.acm#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.acm#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.acm#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateCertificateOptionsCommandError");
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AccessDeniedExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ConflictExceptionRes");
+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_InvalidDomainValidationOptionsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidDomainValidationOptionsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidDomainValidationOptionsExceptionRes");
+var de_InvalidParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidParameterException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidParameterExceptionRes");
+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_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_ResourceInUseExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceInUseException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceInUseExceptionRes");
+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_TagPolicyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TagPolicyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TagPolicyExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ThrottlingExceptionRes");
+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 de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ValidationExceptionRes");
+var se_ExportCertificateRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    CertificateArn: [],
+    Passphrase: context.base64Encoder
+  });
+}, "se_ExportCertificateRequest");
+var se_ImportCertificateRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Certificate: context.base64Encoder,
+    CertificateArn: [],
+    CertificateChain: context.base64Encoder,
+    PrivateKey: context.base64Encoder,
+    Tags: import_smithy_client._json
+  });
+}, "se_ImportCertificateRequest");
+var de_CertificateDetail = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CertificateArn: import_smithy_client.expectString,
+    CertificateAuthorityArn: import_smithy_client.expectString,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DomainName: import_smithy_client.expectString,
+    DomainValidationOptions: import_smithy_client._json,
+    ExtendedKeyUsages: import_smithy_client._json,
+    FailureReason: import_smithy_client.expectString,
+    ImportedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InUseBy: import_smithy_client._json,
+    IssuedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Issuer: import_smithy_client.expectString,
+    KeyAlgorithm: import_smithy_client.expectString,
+    KeyUsages: import_smithy_client._json,
+    NotAfter: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NotBefore: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Options: import_smithy_client._json,
+    RenewalEligibility: import_smithy_client.expectString,
+    RenewalSummary: (_) => de_RenewalSummary(_, context),
+    RevocationReason: import_smithy_client.expectString,
+    RevokedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Serial: import_smithy_client.expectString,
+    SignatureAlgorithm: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Subject: import_smithy_client.expectString,
+    SubjectAlternativeNames: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+}, "de_CertificateDetail");
+var de_CertificateSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CertificateArn: import_smithy_client.expectString,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    DomainName: import_smithy_client.expectString,
+    Exported: import_smithy_client.expectBoolean,
+    ExtendedKeyUsages: import_smithy_client._json,
+    HasAdditionalSubjectAlternativeNames: import_smithy_client.expectBoolean,
+    ImportedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InUse: import_smithy_client.expectBoolean,
+    IssuedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    KeyAlgorithm: import_smithy_client.expectString,
+    KeyUsages: import_smithy_client._json,
+    NotAfter: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NotBefore: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    RenewalEligibility: import_smithy_client.expectString,
+    RevokedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString,
+    SubjectAlternativeNameSummaries: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+}, "de_CertificateSummary");
+var de_CertificateSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CertificateSummary(entry, context);
+  });
+  return retVal;
+}, "de_CertificateSummaryList");
+var de_DescribeCertificateResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Certificate: (_) => de_CertificateDetail(_, context)
+  });
+}, "de_DescribeCertificateResponse");
+var de_ListCertificatesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CertificateSummaryList: (_) => de_CertificateSummaryList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListCertificatesResponse");
+var de_RenewalSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DomainValidationOptions: import_smithy_client._json,
+    RenewalStatus: import_smithy_client.expectString,
+    RenewalStatusReason: import_smithy_client.expectString,
+    UpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_RenewalSummary");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(ACMServiceException);
+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": `CertificateManager.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/AddTagsToCertificateCommand.ts
+var _AddTagsToCertificateCommand = class _AddTagsToCertificateCommand 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("CertificateManager", "AddTagsToCertificate", {}).n("ACMClient", "AddTagsToCertificateCommand").f(void 0, void 0).ser(se_AddTagsToCertificateCommand).de(de_AddTagsToCertificateCommand).build() {
+};
+__name(_AddTagsToCertificateCommand, "AddTagsToCertificateCommand");
+var AddTagsToCertificateCommand = _AddTagsToCertificateCommand;
+
+// src/commands/DeleteCertificateCommand.ts
+
+
+
+
+var _DeleteCertificateCommand = class _DeleteCertificateCommand 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("CertificateManager", "DeleteCertificate", {}).n("ACMClient", "DeleteCertificateCommand").f(void 0, void 0).ser(se_DeleteCertificateCommand).de(de_DeleteCertificateCommand).build() {
+};
+__name(_DeleteCertificateCommand, "DeleteCertificateCommand");
+var DeleteCertificateCommand = _DeleteCertificateCommand;
+
+// src/commands/DescribeCertificateCommand.ts
+
+
+
+
+var _DescribeCertificateCommand = class _DescribeCertificateCommand 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("CertificateManager", "DescribeCertificate", {}).n("ACMClient", "DescribeCertificateCommand").f(void 0, void 0).ser(se_DescribeCertificateCommand).de(de_DescribeCertificateCommand).build() {
+};
+__name(_DescribeCertificateCommand, "DescribeCertificateCommand");
+var DescribeCertificateCommand = _DescribeCertificateCommand;
+
+// src/commands/ExportCertificateCommand.ts
+
+
+
+
+var _ExportCertificateCommand = class _ExportCertificateCommand 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("CertificateManager", "ExportCertificate", {}).n("ACMClient", "ExportCertificateCommand").f(ExportCertificateRequestFilterSensitiveLog, ExportCertificateResponseFilterSensitiveLog).ser(se_ExportCertificateCommand).de(de_ExportCertificateCommand).build() {
+};
+__name(_ExportCertificateCommand, "ExportCertificateCommand");
+var ExportCertificateCommand = _ExportCertificateCommand;
+
+// src/commands/GetAccountConfigurationCommand.ts
+
+
+
+
+var _GetAccountConfigurationCommand = class _GetAccountConfigurationCommand 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("CertificateManager", "GetAccountConfiguration", {}).n("ACMClient", "GetAccountConfigurationCommand").f(void 0, void 0).ser(se_GetAccountConfigurationCommand).de(de_GetAccountConfigurationCommand).build() {
+};
+__name(_GetAccountConfigurationCommand, "GetAccountConfigurationCommand");
+var GetAccountConfigurationCommand = _GetAccountConfigurationCommand;
+
+// src/commands/GetCertificateCommand.ts
+
+
+
+
+var _GetCertificateCommand = class _GetCertificateCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("CertificateManager", "GetCertificate", {}).n("ACMClient", "GetCertificateCommand").f(void 0, void 0).ser(se_GetCertificateCommand).de(de_GetCertificateCommand).build() {
+};
+__name(_GetCertificateCommand, "GetCertificateCommand");
+var GetCertificateCommand = _GetCertificateCommand;
+
+// src/commands/ImportCertificateCommand.ts
+
+
+
+
+var _ImportCertificateCommand = class _ImportCertificateCommand 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("CertificateManager", "ImportCertificate", {}).n("ACMClient", "ImportCertificateCommand").f(ImportCertificateRequestFilterSensitiveLog, void 0).ser(se_ImportCertificateCommand).de(de_ImportCertificateCommand).build() {
+};
+__name(_ImportCertificateCommand, "ImportCertificateCommand");
+var ImportCertificateCommand = _ImportCertificateCommand;
+
+// src/commands/ListCertificatesCommand.ts
+
+
+
+
+var _ListCertificatesCommand = class _ListCertificatesCommand 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("CertificateManager", "ListCertificates", {}).n("ACMClient", "ListCertificatesCommand").f(void 0, void 0).ser(se_ListCertificatesCommand).de(de_ListCertificatesCommand).build() {
+};
+__name(_ListCertificatesCommand, "ListCertificatesCommand");
+var ListCertificatesCommand = _ListCertificatesCommand;
+
+// src/commands/ListTagsForCertificateCommand.ts
+
+
+
+
+var _ListTagsForCertificateCommand = class _ListTagsForCertificateCommand 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("CertificateManager", "ListTagsForCertificate", {}).n("ACMClient", "ListTagsForCertificateCommand").f(void 0, void 0).ser(se_ListTagsForCertificateCommand).de(de_ListTagsForCertificateCommand).build() {
+};
+__name(_ListTagsForCertificateCommand, "ListTagsForCertificateCommand");
+var ListTagsForCertificateCommand = _ListTagsForCertificateCommand;
+
+// src/commands/PutAccountConfigurationCommand.ts
+
+
+
+
+var _PutAccountConfigurationCommand = class _PutAccountConfigurationCommand 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("CertificateManager", "PutAccountConfiguration", {}).n("ACMClient", "PutAccountConfigurationCommand").f(void 0, void 0).ser(se_PutAccountConfigurationCommand).de(de_PutAccountConfigurationCommand).build() {
+};
+__name(_PutAccountConfigurationCommand, "PutAccountConfigurationCommand");
+var PutAccountConfigurationCommand = _PutAccountConfigurationCommand;
+
+// src/commands/RemoveTagsFromCertificateCommand.ts
+
+
+
+
+var _RemoveTagsFromCertificateCommand = class _RemoveTagsFromCertificateCommand 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("CertificateManager", "RemoveTagsFromCertificate", {}).n("ACMClient", "RemoveTagsFromCertificateCommand").f(void 0, void 0).ser(se_RemoveTagsFromCertificateCommand).de(de_RemoveTagsFromCertificateCommand).build() {
+};
+__name(_RemoveTagsFromCertificateCommand, "RemoveTagsFromCertificateCommand");
+var RemoveTagsFromCertificateCommand = _RemoveTagsFromCertificateCommand;
+
+// src/commands/RenewCertificateCommand.ts
+
+
+
+
+var _RenewCertificateCommand = class _RenewCertificateCommand 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("CertificateManager", "RenewCertificate", {}).n("ACMClient", "RenewCertificateCommand").f(void 0, void 0).ser(se_RenewCertificateCommand).de(de_RenewCertificateCommand).build() {
+};
+__name(_RenewCertificateCommand, "RenewCertificateCommand");
+var RenewCertificateCommand = _RenewCertificateCommand;
+
+// src/commands/RequestCertificateCommand.ts
+
+
+
+
+var _RequestCertificateCommand = class _RequestCertificateCommand 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("CertificateManager", "RequestCertificate", {}).n("ACMClient", "RequestCertificateCommand").f(void 0, void 0).ser(se_RequestCertificateCommand).de(de_RequestCertificateCommand).build() {
+};
+__name(_RequestCertificateCommand, "RequestCertificateCommand");
+var RequestCertificateCommand = _RequestCertificateCommand;
+
+// src/commands/ResendValidationEmailCommand.ts
+
+
+
+
+var _ResendValidationEmailCommand = class _ResendValidationEmailCommand 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("CertificateManager", "ResendValidationEmail", {}).n("ACMClient", "ResendValidationEmailCommand").f(void 0, void 0).ser(se_ResendValidationEmailCommand).de(de_ResendValidationEmailCommand).build() {
+};
+__name(_ResendValidationEmailCommand, "ResendValidationEmailCommand");
+var ResendValidationEmailCommand = _ResendValidationEmailCommand;
+
+// src/commands/UpdateCertificateOptionsCommand.ts
+
+
+
+
+var _UpdateCertificateOptionsCommand = class _UpdateCertificateOptionsCommand 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("CertificateManager", "UpdateCertificateOptions", {}).n("ACMClient", "UpdateCertificateOptionsCommand").f(void 0, void 0).ser(se_UpdateCertificateOptionsCommand).de(de_UpdateCertificateOptionsCommand).build() {
+};
+__name(_UpdateCertificateOptionsCommand, "UpdateCertificateOptionsCommand");
+var UpdateCertificateOptionsCommand = _UpdateCertificateOptionsCommand;
+
+// src/ACM.ts
+var commands = {
+  AddTagsToCertificateCommand,
+  DeleteCertificateCommand,
+  DescribeCertificateCommand,
+  ExportCertificateCommand,
+  GetAccountConfigurationCommand,
+  GetCertificateCommand,
+  ImportCertificateCommand,
+  ListCertificatesCommand,
+  ListTagsForCertificateCommand,
+  PutAccountConfigurationCommand,
+  RemoveTagsFromCertificateCommand,
+  RenewCertificateCommand,
+  RequestCertificateCommand,
+  ResendValidationEmailCommand,
+  UpdateCertificateOptionsCommand
+};
+var _ACM = class _ACM extends ACMClient {
+};
+__name(_ACM, "ACM");
+var ACM = _ACM;
+(0, import_smithy_client.createAggregatedClient)(commands, ACM);
+
+// src/pagination/ListCertificatesPaginator.ts
+var import_core = require("@smithy/core");
+var paginateListCertificates = (0, import_core.createPaginator)(ACMClient, ListCertificatesCommand, "NextToken", "NextToken", "MaxItems");
+
+// src/waiters/waitForCertificateValidated.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 DescribeCertificateCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Certificate.DomainValidationOptions);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.ValidationStatus;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "SUCCESS";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Certificate.DomainValidationOptions);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.ValidationStatus;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "PENDING_VALIDATION") {
+          return { state: import_util_waiter.WaiterState.RETRY, reason };
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Certificate.Status;
+      }, "returnComparator");
+      if (returnComparator() === "FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "ResourceNotFoundException") {
+      return { state: import_util_waiter.WaiterState.FAILURE, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForCertificateValidated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForCertificateValidated");
+var waitUntilCertificateValidated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilCertificateValidated");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACM,
+  ACMClient,
+  ACMServiceException,
+  AccessDeniedException,
+  AddTagsToCertificateCommand,
+  CertificateStatus,
+  CertificateTransparencyLoggingPreference,
+  CertificateType,
+  ConflictException,
+  DeleteCertificateCommand,
+  DescribeCertificateCommand,
+  DomainStatus,
+  ExportCertificateCommand,
+  ExportCertificateRequestFilterSensitiveLog,
+  ExportCertificateResponseFilterSensitiveLog,
+  ExtendedKeyUsageName,
+  FailureReason,
+  GetAccountConfigurationCommand,
+  GetCertificateCommand,
+  ImportCertificateCommand,
+  ImportCertificateRequestFilterSensitiveLog,
+  InvalidArgsException,
+  InvalidArnException,
+  InvalidDomainValidationOptionsException,
+  InvalidParameterException,
+  InvalidStateException,
+  InvalidTagException,
+  KeyAlgorithm,
+  KeyUsageName,
+  LimitExceededException,
+  ListCertificatesCommand,
+  ListTagsForCertificateCommand,
+  PutAccountConfigurationCommand,
+  RecordType,
+  RemoveTagsFromCertificateCommand,
+  RenewCertificateCommand,
+  RenewalEligibility,
+  RenewalStatus,
+  RequestCertificateCommand,
+  RequestInProgressException,
+  ResendValidationEmailCommand,
+  ResourceInUseException,
+  ResourceNotFoundException,
+  RevocationReason,
+  SortBy,
+  SortOrder,
+  TagPolicyException,
+  ThrottlingException,
+  TooManyTagsException,
+  UpdateCertificateOptionsCommand,
+  ValidationException,
+  ValidationMethod,
+  __Client,
+  paginateListCertificates,
+  waitForCertificateValidated,
+  waitUntilCertificateValidated
+});