@rio-cloud/cdk-v2-constructs 9.0.0-alpha.2 → 9.0.0-alpha.4

package/node_modules/@aws-sdk/client-acm/dist-cjs/index.js

@@ -0,0 +1,637 @@
+'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 schema = require('@smithy/core/schema');
+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 schemas_0 = require('./schemas/schemas_0');
+var utilWaiter = require('@smithy/util-waiter');
+var errors = require('./models/errors');
+var ACMServiceException = require('./models/ACMServiceException');
+
+const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "acm",
+    });
+};
+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 ACMClient 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(schema.getSchemaSerdePlugin(this.config));
+        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.defaultACMHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
+    }
+}
+
+class AddTagsToCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "AddTagsToCertificate", {})
+    .n("ACMClient", "AddTagsToCertificateCommand")
+    .sc(schemas_0.AddTagsToCertificate$)
+    .build() {
+}
+
+class DeleteCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "DeleteCertificate", {})
+    .n("ACMClient", "DeleteCertificateCommand")
+    .sc(schemas_0.DeleteCertificate$)
+    .build() {
+}
+
+class DescribeCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "DescribeCertificate", {})
+    .n("ACMClient", "DescribeCertificateCommand")
+    .sc(schemas_0.DescribeCertificate$)
+    .build() {
+}
+
+class ExportCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "ExportCertificate", {})
+    .n("ACMClient", "ExportCertificateCommand")
+    .sc(schemas_0.ExportCertificate$)
+    .build() {
+}
+
+class GetAccountConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "GetAccountConfiguration", {})
+    .n("ACMClient", "GetAccountConfigurationCommand")
+    .sc(schemas_0.GetAccountConfiguration$)
+    .build() {
+}
+
+class GetCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "GetCertificate", {})
+    .n("ACMClient", "GetCertificateCommand")
+    .sc(schemas_0.GetCertificate$)
+    .build() {
+}
+
+class ImportCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "ImportCertificate", {})
+    .n("ACMClient", "ImportCertificateCommand")
+    .sc(schemas_0.ImportCertificate$)
+    .build() {
+}
+
+class ListCertificatesCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "ListCertificates", {})
+    .n("ACMClient", "ListCertificatesCommand")
+    .sc(schemas_0.ListCertificates$)
+    .build() {
+}
+
+class ListTagsForCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "ListTagsForCertificate", {})
+    .n("ACMClient", "ListTagsForCertificateCommand")
+    .sc(schemas_0.ListTagsForCertificate$)
+    .build() {
+}
+
+class PutAccountConfigurationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "PutAccountConfiguration", {})
+    .n("ACMClient", "PutAccountConfigurationCommand")
+    .sc(schemas_0.PutAccountConfiguration$)
+    .build() {
+}
+
+class RemoveTagsFromCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "RemoveTagsFromCertificate", {})
+    .n("ACMClient", "RemoveTagsFromCertificateCommand")
+    .sc(schemas_0.RemoveTagsFromCertificate$)
+    .build() {
+}
+
+class RenewCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "RenewCertificate", {})
+    .n("ACMClient", "RenewCertificateCommand")
+    .sc(schemas_0.RenewCertificate$)
+    .build() {
+}
+
+class RequestCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "RequestCertificate", {})
+    .n("ACMClient", "RequestCertificateCommand")
+    .sc(schemas_0.RequestCertificate$)
+    .build() {
+}
+
+class ResendValidationEmailCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "ResendValidationEmail", {})
+    .n("ACMClient", "ResendValidationEmailCommand")
+    .sc(schemas_0.ResendValidationEmail$)
+    .build() {
+}
+
+class RevokeCertificateCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "RevokeCertificate", {})
+    .n("ACMClient", "RevokeCertificateCommand")
+    .sc(schemas_0.RevokeCertificate$)
+    .build() {
+}
+
+class SearchCertificatesCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "SearchCertificates", {})
+    .n("ACMClient", "SearchCertificatesCommand")
+    .sc(schemas_0.SearchCertificates$)
+    .build() {
+}
+
+class UpdateCertificateOptionsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("CertificateManager", "UpdateCertificateOptions", {})
+    .n("ACMClient", "UpdateCertificateOptionsCommand")
+    .sc(schemas_0.UpdateCertificateOptions$)
+    .build() {
+}
+
+const paginateListCertificates = core.createPaginator(ACMClient, ListCertificatesCommand, "NextToken", "NextToken", "MaxItems");
+
+const paginateSearchCertificates = core.createPaginator(ACMClient, SearchCertificatesCommand, "NextToken", "NextToken", "MaxResults");
+
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new DescribeCertificateCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Certificate.DomainValidationOptions);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.ValidationStatus;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
+            }
+            if (allStringEq_5) {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Certificate.DomainValidationOptions);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.ValidationStatus;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "PENDING_VALIDATION") {
+                    return { state: utilWaiter.WaiterState.RETRY, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.Certificate.Status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: utilWaiter.WaiterState.FAILURE, reason };
+        }
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForCertificateValidated = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+const waitUntilCertificateValidated = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return utilWaiter.checkExceptions(result);
+};
+
+const commands = {
+    AddTagsToCertificateCommand,
+    DeleteCertificateCommand,
+    DescribeCertificateCommand,
+    ExportCertificateCommand,
+    GetAccountConfigurationCommand,
+    GetCertificateCommand,
+    ImportCertificateCommand,
+    ListCertificatesCommand,
+    ListTagsForCertificateCommand,
+    PutAccountConfigurationCommand,
+    RemoveTagsFromCertificateCommand,
+    RenewCertificateCommand,
+    RequestCertificateCommand,
+    ResendValidationEmailCommand,
+    RevokeCertificateCommand,
+    SearchCertificatesCommand,
+    UpdateCertificateOptionsCommand,
+};
+const paginators = {
+    paginateListCertificates,
+    paginateSearchCertificates,
+};
+const waiters = {
+    waitUntilCertificateValidated,
+};
+class ACM extends ACMClient {
+}
+smithyClient.createAggregatedClient(commands, ACM, { paginators, waiters });
+
+const CertificateExport = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+const CertificateManagedBy = {
+    CLOUDFRONT: "CLOUDFRONT",
+};
+const RenewalEligibility = {
+    ELIGIBLE: "ELIGIBLE",
+    INELIGIBLE: "INELIGIBLE",
+};
+const RenewalStatus = {
+    FAILED: "FAILED",
+    PENDING_AUTO_RENEWAL: "PENDING_AUTO_RENEWAL",
+    PENDING_VALIDATION: "PENDING_VALIDATION",
+    SUCCESS: "SUCCESS",
+};
+const CertificateStatus = {
+    EXPIRED: "EXPIRED",
+    FAILED: "FAILED",
+    INACTIVE: "INACTIVE",
+    ISSUED: "ISSUED",
+    PENDING_VALIDATION: "PENDING_VALIDATION",
+    REVOKED: "REVOKED",
+    VALIDATION_TIMED_OUT: "VALIDATION_TIMED_OUT",
+};
+const CertificateType = {
+    AMAZON_ISSUED: "AMAZON_ISSUED",
+    IMPORTED: "IMPORTED",
+    PRIVATE: "PRIVATE",
+};
+const ValidationMethod = {
+    DNS: "DNS",
+    EMAIL: "EMAIL",
+    HTTP: "HTTP",
+};
+const RecordType = {
+    CNAME: "CNAME",
+};
+const DomainStatus = {
+    FAILED: "FAILED",
+    PENDING_VALIDATION: "PENDING_VALIDATION",
+    SUCCESS: "SUCCESS",
+};
+const 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",
+};
+const 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",
+};
+const 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",
+};
+const 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",
+};
+const CertificateTransparencyLoggingPreference = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+const 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",
+    SUPERSEDED: "SUPERSEDED",
+    UNSPECIFIED: "UNSPECIFIED",
+};
+const ComparisonOperator = {
+    CONTAINS: "CONTAINS",
+    EQUALS: "EQUALS",
+};
+const SortBy = {
+    CREATED_AT: "CREATED_AT",
+};
+const SortOrder = {
+    ASCENDING: "ASCENDING",
+    DESCENDING: "DESCENDING",
+};
+const SearchCertificatesSortBy = {
+    CERTIFICATE_ARN: "CERTIFICATE_ARN",
+    COMMON_NAME: "COMMON_NAME",
+    CREATED_AT: "CREATED_AT",
+    EXPORTED: "EXPORTED",
+    EXPORT_OPTION: "EXPORT_OPTION",
+    IMPORTED_AT: "IMPORTED_AT",
+    IN_USE: "IN_USE",
+    ISSUED_AT: "ISSUED_AT",
+    KEY_ALGORITHM: "KEY_ALGORITHM",
+    MANAGED_BY: "MANAGED_BY",
+    NOT_AFTER: "NOT_AFTER",
+    NOT_BEFORE: "NOT_BEFORE",
+    RENEWAL_ELIGIBILITY: "RENEWAL_ELIGIBILITY",
+    RENEWAL_STATUS: "RENEWAL_STATUS",
+    REVOKED_AT: "REVOKED_AT",
+    STATUS: "STATUS",
+    TYPE: "TYPE",
+    VALIDATION_METHOD: "VALIDATION_METHOD",
+};
+const SearchCertificatesSortOrder = {
+    ASCENDING: "ASCENDING",
+    DESCENDING: "DESCENDING",
+};
+
+exports.$Command = smithyClient.Command;
+exports.__Client = smithyClient.Client;
+exports.ACMServiceException = ACMServiceException.ACMServiceException;
+exports.ACM = ACM;
+exports.ACMClient = ACMClient;
+exports.AddTagsToCertificateCommand = AddTagsToCertificateCommand;
+exports.CertificateExport = CertificateExport;
+exports.CertificateManagedBy = CertificateManagedBy;
+exports.CertificateStatus = CertificateStatus;
+exports.CertificateTransparencyLoggingPreference = CertificateTransparencyLoggingPreference;
+exports.CertificateType = CertificateType;
+exports.ComparisonOperator = ComparisonOperator;
+exports.DeleteCertificateCommand = DeleteCertificateCommand;
+exports.DescribeCertificateCommand = DescribeCertificateCommand;
+exports.DomainStatus = DomainStatus;
+exports.ExportCertificateCommand = ExportCertificateCommand;
+exports.ExtendedKeyUsageName = ExtendedKeyUsageName;
+exports.FailureReason = FailureReason;
+exports.GetAccountConfigurationCommand = GetAccountConfigurationCommand;
+exports.GetCertificateCommand = GetCertificateCommand;
+exports.ImportCertificateCommand = ImportCertificateCommand;
+exports.KeyAlgorithm = KeyAlgorithm;
+exports.KeyUsageName = KeyUsageName;
+exports.ListCertificatesCommand = ListCertificatesCommand;
+exports.ListTagsForCertificateCommand = ListTagsForCertificateCommand;
+exports.PutAccountConfigurationCommand = PutAccountConfigurationCommand;
+exports.RecordType = RecordType;
+exports.RemoveTagsFromCertificateCommand = RemoveTagsFromCertificateCommand;
+exports.RenewCertificateCommand = RenewCertificateCommand;
+exports.RenewalEligibility = RenewalEligibility;
+exports.RenewalStatus = RenewalStatus;
+exports.RequestCertificateCommand = RequestCertificateCommand;
+exports.ResendValidationEmailCommand = ResendValidationEmailCommand;
+exports.RevocationReason = RevocationReason;
+exports.RevokeCertificateCommand = RevokeCertificateCommand;
+exports.SearchCertificatesCommand = SearchCertificatesCommand;
+exports.SearchCertificatesSortBy = SearchCertificatesSortBy;
+exports.SearchCertificatesSortOrder = SearchCertificatesSortOrder;
+exports.SortBy = SortBy;
+exports.SortOrder = SortOrder;
+exports.UpdateCertificateOptionsCommand = UpdateCertificateOptionsCommand;
+exports.ValidationMethod = ValidationMethod;
+exports.paginateListCertificates = paginateListCertificates;
+exports.paginateSearchCertificates = paginateSearchCertificates;
+exports.waitForCertificateValidated = waitForCertificateValidated;
+exports.waitUntilCertificateValidated = waitUntilCertificateValidated;
+Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
+    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+    Object.defineProperty(exports, '__proto__', {
+        enumerable: true,
+        value: schemas_0['__proto__']
+    });
+
+Object.keys(schemas_0).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
+});
+Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
+    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
+    Object.defineProperty(exports, '__proto__', {
+        enumerable: true,
+        value: errors['__proto__']
+    });
+
+Object.keys(errors).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
+});

package/node_modules/@aws-sdk/client-acm/dist-cjs/models/ACMServiceException.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACMServiceException = exports.__ServiceException = void 0;
+const smithy_client_1 = require("@smithy/smithy-client");
+Object.defineProperty(exports, "__ServiceException", { enumerable: true, get: function () { return smithy_client_1.ServiceException; } });
+class ACMServiceException extends smithy_client_1.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, ACMServiceException.prototype);
+    }
+}
+exports.ACMServiceException = ACMServiceException;