@aws-sdk/client-acm 3.926.0 → 3.928.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 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');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 var utilWaiter = require('@smithy/util-waiter');
 
 const resolveClientEndpointParameters = (options) => {
@@ -92,6 +91,7 @@ class ACMClient extends smithyClient.Client {
         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));
@@ -111,14 +111,14 @@ class ACMClient extends smithyClient.Client {
     }
 }
 
-class ACMServiceException extends smithyClient.ServiceException {
+let ACMServiceException$1 = class ACMServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, ACMServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends ACMServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends ACMServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -131,8 +131,8 @@ class AccessDeniedException extends ACMServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidArnException extends ACMServiceException {
+};
+let InvalidArnException$1 = class InvalidArnException extends ACMServiceException$1 {
     name = "InvalidArnException";
     $fault = "client";
     constructor(opts) {
@@ -143,8 +143,8 @@ class InvalidArnException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, InvalidArnException.prototype);
     }
-}
-class InvalidParameterException extends ACMServiceException {
+};
+let InvalidParameterException$1 = class InvalidParameterException extends ACMServiceException$1 {
     name = "InvalidParameterException";
     $fault = "client";
     constructor(opts) {
@@ -155,8 +155,8 @@ class InvalidParameterException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, InvalidParameterException.prototype);
     }
-}
-class InvalidTagException extends ACMServiceException {
+};
+let InvalidTagException$1 = class InvalidTagException extends ACMServiceException$1 {
     name = "InvalidTagException";
     $fault = "client";
     constructor(opts) {
@@ -167,8 +167,8 @@ class InvalidTagException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, InvalidTagException.prototype);
     }
-}
-class ResourceNotFoundException extends ACMServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends ACMServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -179,8 +179,8 @@ class ResourceNotFoundException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class TagPolicyException extends ACMServiceException {
+};
+let TagPolicyException$1 = class TagPolicyException extends ACMServiceException$1 {
     name = "TagPolicyException";
     $fault = "client";
     constructor(opts) {
@@ -191,8 +191,8 @@ class TagPolicyException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, TagPolicyException.prototype);
     }
-}
-class ThrottlingException extends ACMServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends ACMServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -203,8 +203,8 @@ class ThrottlingException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
-class TooManyTagsException extends ACMServiceException {
+};
+let TooManyTagsException$1 = class TooManyTagsException extends ACMServiceException$1 {
     name = "TooManyTagsException";
     $fault = "client";
     constructor(opts) {
@@ -215,7 +215,7 @@ class TooManyTagsException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, TooManyTagsException.prototype);
     }
-}
+};
 const RecordType = {
     CNAME: "CNAME",
 };
@@ -332,7 +332,7 @@ const CertificateType = {
     IMPORTED: "IMPORTED",
     PRIVATE: "PRIVATE",
 };
-class ConflictException extends ACMServiceException {
+let ConflictException$1 = class ConflictException extends ACMServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -343,8 +343,8 @@ class ConflictException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
-class ResourceInUseException extends ACMServiceException {
+};
+let ResourceInUseException$1 = class ResourceInUseException extends ACMServiceException$1 {
     name = "ResourceInUseException";
     $fault = "client";
     constructor(opts) {
@@ -355,8 +355,8 @@ class ResourceInUseException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, ResourceInUseException.prototype);
     }
-}
-class RequestInProgressException extends ACMServiceException {
+};
+let RequestInProgressException$1 = class RequestInProgressException extends ACMServiceException$1 {
     name = "RequestInProgressException";
     $fault = "client";
     constructor(opts) {
@@ -367,8 +367,8 @@ class RequestInProgressException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, RequestInProgressException.prototype);
     }
-}
-class LimitExceededException extends ACMServiceException {
+};
+let LimitExceededException$1 = class LimitExceededException extends ACMServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     constructor(opts) {
@@ -379,8 +379,8 @@ class LimitExceededException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, LimitExceededException.prototype);
     }
-}
-class InvalidArgsException extends ACMServiceException {
+};
+let InvalidArgsException$1 = class InvalidArgsException extends ACMServiceException$1 {
     name = "InvalidArgsException";
     $fault = "client";
     constructor(opts) {
@@ -391,7 +391,7 @@ class InvalidArgsException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, InvalidArgsException.prototype);
     }
-}
+};
 const SortBy = {
     CREATED_AT: "CREATED_AT",
 };
@@ -399,7 +399,7 @@ const SortOrder = {
     ASCENDING: "ASCENDING",
     DESCENDING: "DESCENDING",
 };
-class ValidationException extends ACMServiceException {
+let ValidationException$1 = class ValidationException extends ACMServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     constructor(opts) {
@@ -410,8 +410,8 @@ class ValidationException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
-}
-class InvalidDomainValidationOptionsException extends ACMServiceException {
+};
+let InvalidDomainValidationOptionsException$1 = class InvalidDomainValidationOptionsException extends ACMServiceException$1 {
     name = "InvalidDomainValidationOptionsException";
     $fault = "client";
     constructor(opts) {
@@ -422,8 +422,8 @@ class InvalidDomainValidationOptionsException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, InvalidDomainValidationOptionsException.prototype);
     }
-}
-class InvalidStateException extends ACMServiceException {
+};
+let InvalidStateException$1 = class InvalidStateException extends ACMServiceException$1 {
     name = "InvalidStateException";
     $fault = "client";
     constructor(opts) {
@@ -434,650 +434,661 @@ class InvalidStateException extends ACMServiceException {
         });
         Object.setPrototypeOf(this, InvalidStateException.prototype);
     }
-}
-const ExportCertificateRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Passphrase && { Passphrase: smithyClient.SENSITIVE_STRING }),
-});
-const ExportCertificateResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PrivateKey && { PrivateKey: smithyClient.SENSITIVE_STRING }),
-});
-const ImportCertificateRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.PrivateKey && { PrivateKey: smithyClient.SENSITIVE_STRING }),
-});
-
-const se_AddTagsToCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("AddTagsToCertificate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteCertificate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeCertificate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ExportCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("ExportCertificate");
-    let body;
-    body = JSON.stringify(se_ExportCertificateRequest(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetAccountConfigurationCommand = async (input, context) => {
-    const headers = sharedHeaders("GetAccountConfiguration");
-    const body = "{}";
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("GetCertificate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ImportCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("ImportCertificate");
-    let body;
-    body = JSON.stringify(se_ImportCertificateRequest(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListCertificatesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListCertificates");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForCertificate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PutAccountConfigurationCommand = async (input, context) => {
-    const headers = sharedHeaders("PutAccountConfiguration");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RemoveTagsFromCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("RemoveTagsFromCertificate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RenewCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("RenewCertificate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RequestCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("RequestCertificate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ResendValidationEmailCommand = async (input, context) => {
-    const headers = sharedHeaders("ResendValidationEmail");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RevokeCertificateCommand = async (input, context) => {
-    const headers = sharedHeaders("RevokeCertificate");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateCertificateOptionsCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateCertificateOptions");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_AddTagsToCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DeleteCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DescribeCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeCertificateResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ExportCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetAccountConfigurationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
 };
-const de_ImportCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListCertificatesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListCertificatesResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutAccountConfigurationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RemoveTagsFromCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RenewCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RequestCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ResendValidationEmailCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RevokeCertificateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateCertificateOptionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArnException":
-        case "com.amazonaws.acm#InvalidArnException":
-            throw await de_InvalidArnExceptionRes(parsedOutput);
-        case "InvalidParameterException":
-        case "com.amazonaws.acm#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput);
-        case "InvalidTagException":
-        case "com.amazonaws.acm#InvalidTagException":
-            throw await de_InvalidTagExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "TagPolicyException":
-        case "com.amazonaws.acm#TagPolicyException":
-            throw await de_TagPolicyExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.acm#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "TooManyTagsException":
-        case "com.amazonaws.acm#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput);
-        case "AccessDeniedException":
-        case "com.amazonaws.acm#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.acm#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "ResourceInUseException":
-        case "com.amazonaws.acm#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput);
-        case "RequestInProgressException":
-        case "com.amazonaws.acm#RequestInProgressException":
-            throw await de_RequestInProgressExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.acm#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        case "InvalidArgsException":
-        case "com.amazonaws.acm#InvalidArgsException":
-            throw await de_InvalidArgsExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.acm#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "InvalidDomainValidationOptionsException":
-        case "com.amazonaws.acm#InvalidDomainValidationOptionsException":
-            throw await de_InvalidDomainValidationOptionsExceptionRes(parsedOutput);
-        case "InvalidStateException":
-        case "com.amazonaws.acm#InvalidStateException":
-            throw await de_InvalidStateExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidArgsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidArgsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidArnExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidArnException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidDomainValidationOptionsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidDomainValidationOptionsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidParameterException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidStateExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidStateException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidTagExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidTagException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_RequestInProgressExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new RequestInProgressException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceInUseException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TagPolicyExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TagPolicyException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TooManyTagsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_ExportCertificateRequest = (input, context) => {
-    return smithyClient.take(input, {
-        CertificateArn: [],
-        Passphrase: context.base64Encoder,
-    });
-};
-const se_ImportCertificateRequest = (input, context) => {
-    return smithyClient.take(input, {
-        Certificate: context.base64Encoder,
-        CertificateArn: [],
-        CertificateChain: context.base64Encoder,
-        PrivateKey: context.base64Encoder,
-        Tags: smithyClient._json,
-    });
-};
-const de_CertificateDetail = (output, context) => {
-    return smithyClient.take(output, {
-        CertificateArn: smithyClient.expectString,
-        CertificateAuthorityArn: smithyClient.expectString,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DomainName: smithyClient.expectString,
-        DomainValidationOptions: smithyClient._json,
-        ExtendedKeyUsages: smithyClient._json,
-        FailureReason: smithyClient.expectString,
-        ImportedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        InUseBy: smithyClient._json,
-        IssuedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Issuer: smithyClient.expectString,
-        KeyAlgorithm: smithyClient.expectString,
-        KeyUsages: smithyClient._json,
-        ManagedBy: smithyClient.expectString,
-        NotAfter: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NotBefore: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Options: smithyClient._json,
-        RenewalEligibility: smithyClient.expectString,
-        RenewalSummary: (_) => de_RenewalSummary(_),
-        RevocationReason: smithyClient.expectString,
-        RevokedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Serial: smithyClient.expectString,
-        SignatureAlgorithm: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Subject: smithyClient.expectString,
-        SubjectAlternativeNames: smithyClient._json,
-        Type: smithyClient.expectString,
-    });
-};
-const de_CertificateSummary = (output, context) => {
-    return smithyClient.take(output, {
-        CertificateArn: smithyClient.expectString,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DomainName: smithyClient.expectString,
-        ExportOption: smithyClient.expectString,
-        Exported: smithyClient.expectBoolean,
-        ExtendedKeyUsages: smithyClient._json,
-        HasAdditionalSubjectAlternativeNames: smithyClient.expectBoolean,
-        ImportedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        InUse: smithyClient.expectBoolean,
-        IssuedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        KeyAlgorithm: smithyClient.expectString,
-        KeyUsages: smithyClient._json,
-        ManagedBy: smithyClient.expectString,
-        NotAfter: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NotBefore: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        RenewalEligibility: smithyClient.expectString,
-        RevokedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-        SubjectAlternativeNameSummaries: smithyClient._json,
-        Type: smithyClient.expectString,
-    });
-};
-const de_CertificateSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_CertificateSummary(entry);
-    });
-    return retVal;
-};
-const de_DescribeCertificateResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Certificate: (_) => de_CertificateDetail(_),
-    });
-};
-const de_ListCertificatesResponse = (output, context) => {
-    return smithyClient.take(output, {
-        CertificateSummaryList: (_) => de_CertificateSummaryList(_),
-        NextToken: smithyClient.expectString,
-    });
-};
-const de_RenewalSummary = (output, context) => {
-    return smithyClient.take(output, {
-        DomainValidationOptions: smithyClient._json,
-        RenewalStatus: smithyClient.expectString,
-        RenewalStatusReason: smithyClient.expectString,
-        UpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(ACMServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": `CertificateManager.${operation}`,
-    };
-}
+
+const _ADE = "AccessDeniedException";
+const _ATTC = "AddTagsToCertificate";
+const _ATTCR = "AddTagsToCertificateRequest";
+const _C = "Certificate";
+const _CA = "CertificateArn";
+const _CAA = "CertificateAuthorityArn";
+const _CAr = "CreatedAt";
+const _CC = "CertificateChain";
+const _CD = "CertificateDetail";
+const _CE = "ConflictException";
+const _CO = "CertificateOptions";
+const _CS = "CertificateSummary";
+const _CSL = "CertificateSummaryList";
+const _CSe = "CertificateStatuses";
+const _CTLP = "CertificateTransparencyLoggingPreference";
+const _D = "Domain";
+const _DBE = "DaysBeforeExpiry";
+const _DC = "DeleteCertificate";
+const _DCR = "DeleteCertificateRequest";
+const _DCRe = "DescribeCertificateRequest";
+const _DCRes = "DescribeCertificateResponse";
+const _DCe = "DescribeCertificate";
+const _DN = "DomainName";
+const _DV = "DomainValidation";
+const _DVL = "DomainValidationList";
+const _DVO = "DomainValidationOptions";
+const _DVOL = "DomainValidationOptionList";
+const _DVOo = "DomainValidationOption";
+const _E = "Export";
+const _EC = "ExportCertificate";
+const _ECR = "ExportCertificateRequest";
+const _ECRx = "ExportCertificateResponse";
+const _EE = "ExpiryEvents";
+const _EEC = "ExpiryEventsConfiguration";
+const _EKU = "ExtendedKeyUsages";
+const _EKUL = "ExtendedKeyUsageList";
+const _EKUx = "ExtendedKeyUsage";
+const _EO = "ExportOption";
+const _Ex = "Exported";
+const _F = "Filters";
+const _FR = "FailureReason";
+const _GAC = "GetAccountConfiguration";
+const _GACR = "GetAccountConfigurationResponse";
+const _GC = "GetCertificate";
+const _GCR = "GetCertificateRequest";
+const _GCRe = "GetCertificateResponse";
+const _HASAN = "HasAdditionalSubjectAlternativeNames";
+const _HR = "HttpRedirect";
+const _I = "Issuer";
+const _IA = "IssuedAt";
+const _IAE = "InvalidArgsException";
+const _IAEn = "InvalidArnException";
+const _IAm = "ImportedAt";
+const _IC = "ImportCertificate";
+const _ICR = "ImportCertificateRequest";
+const _ICRm = "ImportCertificateResponse";
+const _IDVOE = "InvalidDomainValidationOptionsException";
+const _IPE = "InvalidParameterException";
+const _ISE = "InvalidStateException";
+const _IT = "IdempotencyToken";
+const _ITE = "InvalidTagException";
+const _IU = "InUse";
+const _IUB = "InUseBy";
+const _In = "Includes";
+const _K = "Key";
+const _KA = "KeyAlgorithm";
+const _KU = "KeyUsages";
+const _KUL = "KeyUsageList";
+const _KUe = "KeyUsage";
+const _LC = "ListCertificates";
+const _LCR = "ListCertificatesRequest";
+const _LCRi = "ListCertificatesResponse";
+const _LEE = "LimitExceededException";
+const _LTFC = "ListTagsForCertificate";
+const _LTFCR = "ListTagsForCertificateRequest";
+const _LTFCRi = "ListTagsForCertificateResponse";
+const _M = "Message";
+const _MB = "ManagedBy";
+const _MI = "MaxItems";
+const _N = "Name";
+const _NA = "NotAfter";
+const _NB = "NotBefore";
+const _NT = "NextToken";
+const _O = "Options";
+const _OID = "OID";
+const _P = "Passphrase";
+const _PAC = "PutAccountConfiguration";
+const _PACR = "PutAccountConfigurationRequest";
+const _PB = "PassphraseBlob";
+const _PK = "PrivateKey";
+const _PKB = "PrivateKeyBlob";
+const _RA = "RevokedAt";
+const _RC = "RenewCertificate";
+const _RCR = "RenewCertificateRequest";
+const _RCRe = "RequestCertificateRequest";
+const _RCReq = "RequestCertificateResponse";
+const _RCRev = "RevokeCertificateRequest";
+const _RCRevo = "RevokeCertificateResponse";
+const _RCe = "RequestCertificate";
+const _RCev = "RevokeCertificate";
+const _RE = "RenewalEligibility";
+const _RF = "RedirectFrom";
+const _RIPE = "RequestInProgressException";
+const _RIUE = "ResourceInUseException";
+const _RNFE = "ResourceNotFoundException";
+const _RR = "RevocationReason";
+const _RRe = "ResourceRecord";
+const _RS = "RenewalSummary";
+const _RSR = "RenewalStatusReason";
+const _RSe = "RenewalStatus";
+const _RT = "RedirectTo";
+const _RTFC = "RemoveTagsFromCertificate";
+const _RTFCR = "RemoveTagsFromCertificateRequest";
+const _RVE = "ResendValidationEmail";
+const _RVER = "ResendValidationEmailRequest";
+const _S = "Serial";
+const _SA = "SignatureAlgorithm";
+const _SAN = "SubjectAlternativeNames";
+const _SANS = "SubjectAlternativeNameSummaries";
+const _SB = "SortBy";
+const _SO = "SortOrder";
+const _St = "Status";
+const _Su = "Subject";
+const _T = "Tags";
+const _TE = "ThrottlingException";
+const _TL = "TagList";
+const _TMTE = "TooManyTagsException";
+const _TPE = "TagPolicyException";
+const _Ta = "Tag";
+const _Ty = "Type";
+const _UA = "UpdatedAt";
+const _UCO = "UpdateCertificateOptions";
+const _UCOR = "UpdateCertificateOptionsRequest";
+const _V = "Value";
+const _VD = "ValidationDomain";
+const _VE = "ValidationEmails";
+const _VEa = "ValidationException";
+const _VM = "ValidationMethod";
+const _VS = "ValidationStatus";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _eKU = "extendedKeyUsage";
+const _eO = "exportOption";
+const _hE = "httpError";
+const _kT = "keyTypes";
+const _kU = "keyUsage";
+const _m = "message";
+const _mB = "managedBy";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.acm";
+const n0 = "com.amazonaws.acm";
+var PassphraseBlob = [0, n0, _PB, 8, 21];
+var PrivateKey = [0, n0, _PK, 8, 0];
+var PrivateKeyBlob = [0, n0, _PKB, 8, 21];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+        [_aQE]: [`AccessDenied`, 403],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AddTagsToCertificateRequest = [3, n0, _ATTCR, 0, [_CA, _T], [0, () => TagList]];
+var CertificateDetail = [
+    3,
+    n0,
+    _CD,
+    0,
+    [
+        _CA,
+        _DN,
+        _SAN,
+        _MB,
+        _DVO,
+        _S,
+        _Su,
+        _I,
+        _CAr,
+        _IA,
+        _IAm,
+        _St,
+        _RA,
+        _RR,
+        _NB,
+        _NA,
+        _KA,
+        _SA,
+        _IUB,
+        _FR,
+        _Ty,
+        _RS,
+        _KU,
+        _EKU,
+        _CAA,
+        _RE,
+        _O,
+    ],
+    [
+        0,
+        0,
+        64 | 0,
+        0,
+        () => DomainValidationList,
+        0,
+        0,
+        0,
+        4,
+        4,
+        4,
+        0,
+        4,
+        0,
+        4,
+        4,
+        0,
+        0,
+        64 | 0,
+        0,
+        0,
+        () => RenewalSummary,
+        () => KeyUsageList,
+        () => ExtendedKeyUsageList,
+        0,
+        0,
+        () => CertificateOptions,
+    ],
+];
+var CertificateOptions = [3, n0, _CO, 0, [_CTLP, _E], [0, 0]];
+var CertificateSummary = [
+    3,
+    n0,
+    _CS,
+    0,
+    [_CA, _DN, _SANS, _HASAN, _St, _Ty, _KA, _KU, _EKU, _EO, _IU, _Ex, _RE, _NB, _NA, _CAr, _IA, _IAm, _RA, _MB],
+    [0, 0, 64 | 0, 2, 0, 0, 0, 64 | 0, 64 | 0, 0, 2, 2, 0, 4, 4, 4, 4, 4, 4, 0],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var DeleteCertificateRequest = [3, n0, _DCR, 0, [_CA], [0]];
+var DescribeCertificateRequest = [3, n0, _DCRe, 0, [_CA], [0]];
+var DescribeCertificateResponse = [3, n0, _DCRes, 0, [_C], [() => CertificateDetail]];
+var DomainValidation = [
+    3,
+    n0,
+    _DV,
+    0,
+    [_DN, _VE, _VD, _VS, _RRe, _HR, _VM],
+    [0, 64 | 0, 0, 0, () => ResourceRecord, () => HttpRedirect, 0],
+];
+var DomainValidationOption = [3, n0, _DVOo, 0, [_DN, _VD], [0, 0]];
+var ExpiryEventsConfiguration = [3, n0, _EEC, 0, [_DBE], [1]];
+var ExportCertificateRequest = [
+    3,
+    n0,
+    _ECR,
+    0,
+    [_CA, _P],
+    [0, [() => PassphraseBlob, 0]],
+];
+var ExportCertificateResponse = [
+    3,
+    n0,
+    _ECRx,
+    0,
+    [_C, _CC, _PK],
+    [0, 0, [() => PrivateKey, 0]],
+];
+var ExtendedKeyUsage = [3, n0, _EKUx, 0, [_N, _OID], [0, 0]];
+var Filters = [3, n0, _F, 0, [_eKU, _kU, _kT, _eO, _mB], [64 | 0, 64 | 0, 64 | 0, 0, 0]];
+var GetAccountConfigurationResponse = [
+    3,
+    n0,
+    _GACR,
+    0,
+    [_EE],
+    [() => ExpiryEventsConfiguration],
+];
+var GetCertificateRequest = [3, n0, _GCR, 0, [_CA], [0]];
+var GetCertificateResponse = [3, n0, _GCRe, 0, [_C, _CC], [0, 0]];
+var HttpRedirect = [3, n0, _HR, 0, [_RF, _RT], [0, 0]];
+var ImportCertificateRequest = [
+    3,
+    n0,
+    _ICR,
+    0,
+    [_CA, _C, _PK, _CC, _T],
+    [0, 21, [() => PrivateKeyBlob, 0], 21, () => TagList],
+];
+var ImportCertificateResponse = [3, n0, _ICRm, 0, [_CA], [0]];
+var InvalidArgsException = [
+    -3,
+    n0,
+    _IAE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidArgsException, InvalidArgsException$1);
+var InvalidArnException = [
+    -3,
+    n0,
+    _IAEn,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidArnException, InvalidArnException$1);
+var InvalidDomainValidationOptionsException = [
+    -3,
+    n0,
+    _IDVOE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidDomainValidationOptionsException, InvalidDomainValidationOptionsException$1);
+var InvalidParameterException = [
+    -3,
+    n0,
+    _IPE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidParameterException, InvalidParameterException$1);
+var InvalidStateException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidStateException, InvalidStateException$1);
+var InvalidTagException = [
+    -3,
+    n0,
+    _ITE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidTagException, InvalidTagException$1);
+var KeyUsage = [3, n0, _KUe, 0, [_N], [0]];
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var ListCertificatesRequest = [
+    3,
+    n0,
+    _LCR,
+    0,
+    [_CSe, _In, _NT, _MI, _SB, _SO],
+    [64 | 0, () => Filters, 0, 1, 0, 0],
+];
+var ListCertificatesResponse = [
+    3,
+    n0,
+    _LCRi,
+    0,
+    [_NT, _CSL],
+    [0, () => CertificateSummaryList],
+];
+var ListTagsForCertificateRequest = [3, n0, _LTFCR, 0, [_CA], [0]];
+var ListTagsForCertificateResponse = [3, n0, _LTFCRi, 0, [_T], [() => TagList]];
+var PutAccountConfigurationRequest = [
+    3,
+    n0,
+    _PACR,
+    0,
+    [_EE, _IT],
+    [() => ExpiryEventsConfiguration, 0],
+];
+var RemoveTagsFromCertificateRequest = [3, n0, _RTFCR, 0, [_CA, _T], [0, () => TagList]];
+var RenewalSummary = [
+    3,
+    n0,
+    _RS,
+    0,
+    [_RSe, _DVO, _RSR, _UA],
+    [0, () => DomainValidationList, 0, 4],
+];
+var RenewCertificateRequest = [3, n0, _RCR, 0, [_CA], [0]];
+var RequestCertificateRequest = [
+    3,
+    n0,
+    _RCRe,
+    0,
+    [_DN, _VM, _SAN, _IT, _DVO, _O, _CAA, _T, _KA, _MB],
+    [0, 0, 64 | 0, 0, () => DomainValidationOptionList, () => CertificateOptions, 0, () => TagList, 0, 0],
+];
+var RequestCertificateResponse = [3, n0, _RCReq, 0, [_CA], [0]];
+var RequestInProgressException = [
+    -3,
+    n0,
+    _RIPE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RequestInProgressException, RequestInProgressException$1);
+var ResendValidationEmailRequest = [3, n0, _RVER, 0, [_CA, _D, _VD], [0, 0, 0]];
+var ResourceInUseException = [
+    -3,
+    n0,
+    _RIUE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceInUseException, ResourceInUseException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ResourceRecord = [3, n0, _RRe, 0, [_N, _Ty, _V], [0, 0, 0]];
+var RevokeCertificateRequest = [3, n0, _RCRev, 0, [_CA, _RR], [0, 0]];
+var RevokeCertificateResponse = [3, n0, _RCRevo, 0, [_CA], [0]];
+var Tag = [3, n0, _Ta, 0, [_K, _V], [0, 0]];
+var TagPolicyException = [
+    -3,
+    n0,
+    _TPE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TagPolicyException, TagPolicyException$1);
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`Throttling`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TooManyTagsException = [
+    -3,
+    n0,
+    _TMTE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyTagsException, TooManyTagsException$1);
+var UpdateCertificateOptionsRequest = [
+    3,
+    n0,
+    _UCOR,
+    0,
+    [_CA, _O],
+    [0, () => CertificateOptions],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VEa,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`ValidationError`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var __Unit = "unit";
+var ACMServiceException = [-3, _s, "ACMServiceException", 0, [], []];
+schema.TypeRegistry.for(_s).registerError(ACMServiceException, ACMServiceException$1);
+var CertificateSummaryList = [1, n0, _CSL, 0, () => CertificateSummary];
+var DomainValidationList = [1, n0, _DVL, 0, () => DomainValidation];
+var DomainValidationOptionList = [1, n0, _DVOL, 0, () => DomainValidationOption];
+var ExtendedKeyUsageList = [1, n0, _EKUL, 0, () => ExtendedKeyUsage];
+var KeyUsageList = [1, n0, _KUL, 0, () => KeyUsage];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var AddTagsToCertificate = [
+    9,
+    n0,
+    _ATTC,
+    0,
+    () => AddTagsToCertificateRequest,
+    () => __Unit,
+];
+var DeleteCertificate = [9, n0, _DC, 0, () => DeleteCertificateRequest, () => __Unit];
+var DescribeCertificate = [
+    9,
+    n0,
+    _DCe,
+    0,
+    () => DescribeCertificateRequest,
+    () => DescribeCertificateResponse,
+];
+var ExportCertificate = [
+    9,
+    n0,
+    _EC,
+    0,
+    () => ExportCertificateRequest,
+    () => ExportCertificateResponse,
+];
+var GetAccountConfiguration = [
+    9,
+    n0,
+    _GAC,
+    0,
+    () => __Unit,
+    () => GetAccountConfigurationResponse,
+];
+var GetCertificate = [
+    9,
+    n0,
+    _GC,
+    0,
+    () => GetCertificateRequest,
+    () => GetCertificateResponse,
+];
+var ImportCertificate = [
+    9,
+    n0,
+    _IC,
+    0,
+    () => ImportCertificateRequest,
+    () => ImportCertificateResponse,
+];
+var ListCertificates = [
+    9,
+    n0,
+    _LC,
+    0,
+    () => ListCertificatesRequest,
+    () => ListCertificatesResponse,
+];
+var ListTagsForCertificate = [
+    9,
+    n0,
+    _LTFC,
+    0,
+    () => ListTagsForCertificateRequest,
+    () => ListTagsForCertificateResponse,
+];
+var PutAccountConfiguration = [
+    9,
+    n0,
+    _PAC,
+    0,
+    () => PutAccountConfigurationRequest,
+    () => __Unit,
+];
+var RemoveTagsFromCertificate = [
+    9,
+    n0,
+    _RTFC,
+    0,
+    () => RemoveTagsFromCertificateRequest,
+    () => __Unit,
+];
+var RenewCertificate = [9, n0, _RC, 0, () => RenewCertificateRequest, () => __Unit];
+var RequestCertificate = [
+    9,
+    n0,
+    _RCe,
+    0,
+    () => RequestCertificateRequest,
+    () => RequestCertificateResponse,
+];
+var ResendValidationEmail = [
+    9,
+    n0,
+    _RVE,
+    0,
+    () => ResendValidationEmailRequest,
+    () => __Unit,
+];
+var RevokeCertificate = [
+    9,
+    n0,
+    _RCev,
+    0,
+    () => RevokeCertificateRequest,
+    () => RevokeCertificateResponse,
+];
+var UpdateCertificateOptions = [
+    9,
+    n0,
+    _UCO,
+    0,
+    () => UpdateCertificateOptionsRequest,
+    () => __Unit,
+];
 
 class AddTagsToCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "AddTagsToCertificate", {})
     .n("ACMClient", "AddTagsToCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_AddTagsToCertificateCommand)
-    .de(de_AddTagsToCertificateCommand)
+    .sc(AddTagsToCertificate)
     .build() {
 }
 
@@ -1085,16 +1096,11 @@ class DeleteCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "DeleteCertificate", {})
     .n("ACMClient", "DeleteCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteCertificateCommand)
-    .de(de_DeleteCertificateCommand)
+    .sc(DeleteCertificate)
     .build() {
 }
 
@@ -1102,16 +1108,11 @@ class DescribeCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "DescribeCertificate", {})
     .n("ACMClient", "DescribeCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeCertificateCommand)
-    .de(de_DescribeCertificateCommand)
+    .sc(DescribeCertificate)
     .build() {
 }
 
@@ -1119,16 +1120,11 @@ class ExportCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "ExportCertificate", {})
     .n("ACMClient", "ExportCertificateCommand")
-    .f(ExportCertificateRequestFilterSensitiveLog, ExportCertificateResponseFilterSensitiveLog)
-    .ser(se_ExportCertificateCommand)
-    .de(de_ExportCertificateCommand)
+    .sc(ExportCertificate)
     .build() {
 }
 
@@ -1136,16 +1132,11 @@ class GetAccountConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "GetAccountConfiguration", {})
     .n("ACMClient", "GetAccountConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetAccountConfigurationCommand)
-    .de(de_GetAccountConfigurationCommand)
+    .sc(GetAccountConfiguration)
     .build() {
 }
 
@@ -1153,16 +1144,11 @@ class GetCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "GetCertificate", {})
     .n("ACMClient", "GetCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_GetCertificateCommand)
-    .de(de_GetCertificateCommand)
+    .sc(GetCertificate)
     .build() {
 }
 
@@ -1170,16 +1156,11 @@ class ImportCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "ImportCertificate", {})
     .n("ACMClient", "ImportCertificateCommand")
-    .f(ImportCertificateRequestFilterSensitiveLog, void 0)
-    .ser(se_ImportCertificateCommand)
-    .de(de_ImportCertificateCommand)
+    .sc(ImportCertificate)
     .build() {
 }
 
@@ -1187,16 +1168,11 @@ class ListCertificatesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "ListCertificates", {})
     .n("ACMClient", "ListCertificatesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListCertificatesCommand)
-    .de(de_ListCertificatesCommand)
+    .sc(ListCertificates)
     .build() {
 }
 
@@ -1204,16 +1180,11 @@ class ListTagsForCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "ListTagsForCertificate", {})
     .n("ACMClient", "ListTagsForCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForCertificateCommand)
-    .de(de_ListTagsForCertificateCommand)
+    .sc(ListTagsForCertificate)
     .build() {
 }
 
@@ -1221,16 +1192,11 @@ class PutAccountConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "PutAccountConfiguration", {})
     .n("ACMClient", "PutAccountConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_PutAccountConfigurationCommand)
-    .de(de_PutAccountConfigurationCommand)
+    .sc(PutAccountConfiguration)
     .build() {
 }
 
@@ -1238,16 +1204,11 @@ class RemoveTagsFromCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "RemoveTagsFromCertificate", {})
     .n("ACMClient", "RemoveTagsFromCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_RemoveTagsFromCertificateCommand)
-    .de(de_RemoveTagsFromCertificateCommand)
+    .sc(RemoveTagsFromCertificate)
     .build() {
 }
 
@@ -1255,16 +1216,11 @@ class RenewCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "RenewCertificate", {})
     .n("ACMClient", "RenewCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_RenewCertificateCommand)
-    .de(de_RenewCertificateCommand)
+    .sc(RenewCertificate)
     .build() {
 }
 
@@ -1272,16 +1228,11 @@ class RequestCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "RequestCertificate", {})
     .n("ACMClient", "RequestCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_RequestCertificateCommand)
-    .de(de_RequestCertificateCommand)
+    .sc(RequestCertificate)
     .build() {
 }
 
@@ -1289,16 +1240,11 @@ class ResendValidationEmailCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "ResendValidationEmail", {})
     .n("ACMClient", "ResendValidationEmailCommand")
-    .f(void 0, void 0)
-    .ser(se_ResendValidationEmailCommand)
-    .de(de_ResendValidationEmailCommand)
+    .sc(ResendValidationEmail)
     .build() {
 }
 
@@ -1306,16 +1252,11 @@ class RevokeCertificateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "RevokeCertificate", {})
     .n("ACMClient", "RevokeCertificateCommand")
-    .f(void 0, void 0)
-    .ser(se_RevokeCertificateCommand)
-    .de(de_RevokeCertificateCommand)
+    .sc(RevokeCertificate)
     .build() {
 }
 
@@ -1323,16 +1264,11 @@ class UpdateCertificateOptionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("CertificateManager", "UpdateCertificateOptions", {})
     .n("ACMClient", "UpdateCertificateOptionsCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateCertificateOptionsCommand)
-    .de(de_UpdateCertificateOptionsCommand)
+    .sc(UpdateCertificateOptions)
     .build() {
 }
 
@@ -1435,36 +1371,33 @@ Object.defineProperty(exports, "__Client", {
 });
 exports.ACM = ACM;
 exports.ACMClient = ACMClient;
-exports.ACMServiceException = ACMServiceException;
-exports.AccessDeniedException = AccessDeniedException;
+exports.ACMServiceException = ACMServiceException$1;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AddTagsToCertificateCommand = AddTagsToCertificateCommand;
 exports.CertificateExport = CertificateExport;
 exports.CertificateManagedBy = CertificateManagedBy;
 exports.CertificateStatus = CertificateStatus;
 exports.CertificateTransparencyLoggingPreference = CertificateTransparencyLoggingPreference;
 exports.CertificateType = CertificateType;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.DeleteCertificateCommand = DeleteCertificateCommand;
 exports.DescribeCertificateCommand = DescribeCertificateCommand;
 exports.DomainStatus = DomainStatus;
 exports.ExportCertificateCommand = ExportCertificateCommand;
-exports.ExportCertificateRequestFilterSensitiveLog = ExportCertificateRequestFilterSensitiveLog;
-exports.ExportCertificateResponseFilterSensitiveLog = ExportCertificateResponseFilterSensitiveLog;
 exports.ExtendedKeyUsageName = ExtendedKeyUsageName;
 exports.FailureReason = FailureReason;
 exports.GetAccountConfigurationCommand = GetAccountConfigurationCommand;
 exports.GetCertificateCommand = GetCertificateCommand;
 exports.ImportCertificateCommand = ImportCertificateCommand;
-exports.ImportCertificateRequestFilterSensitiveLog = ImportCertificateRequestFilterSensitiveLog;
-exports.InvalidArgsException = InvalidArgsException;
-exports.InvalidArnException = InvalidArnException;
-exports.InvalidDomainValidationOptionsException = InvalidDomainValidationOptionsException;
-exports.InvalidParameterException = InvalidParameterException;
-exports.InvalidStateException = InvalidStateException;
-exports.InvalidTagException = InvalidTagException;
+exports.InvalidArgsException = InvalidArgsException$1;
+exports.InvalidArnException = InvalidArnException$1;
+exports.InvalidDomainValidationOptionsException = InvalidDomainValidationOptionsException$1;
+exports.InvalidParameterException = InvalidParameterException$1;
+exports.InvalidStateException = InvalidStateException$1;
+exports.InvalidTagException = InvalidTagException$1;
 exports.KeyAlgorithm = KeyAlgorithm;
 exports.KeyUsageName = KeyUsageName;
-exports.LimitExceededException = LimitExceededException;
+exports.LimitExceededException = LimitExceededException$1;
 exports.ListCertificatesCommand = ListCertificatesCommand;
 exports.ListTagsForCertificateCommand = ListTagsForCertificateCommand;
 exports.PutAccountConfigurationCommand = PutAccountConfigurationCommand;
@@ -1474,19 +1407,19 @@ exports.RenewCertificateCommand = RenewCertificateCommand;
 exports.RenewalEligibility = RenewalEligibility;
 exports.RenewalStatus = RenewalStatus;
 exports.RequestCertificateCommand = RequestCertificateCommand;
-exports.RequestInProgressException = RequestInProgressException;
+exports.RequestInProgressException = RequestInProgressException$1;
 exports.ResendValidationEmailCommand = ResendValidationEmailCommand;
-exports.ResourceInUseException = ResourceInUseException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceInUseException = ResourceInUseException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.RevocationReason = RevocationReason;
 exports.RevokeCertificateCommand = RevokeCertificateCommand;
 exports.SortBy = SortBy;
 exports.SortOrder = SortOrder;
-exports.TagPolicyException = TagPolicyException;
-exports.ThrottlingException = ThrottlingException;
-exports.TooManyTagsException = TooManyTagsException;
+exports.TagPolicyException = TagPolicyException$1;
+exports.ThrottlingException = ThrottlingException$1;
+exports.TooManyTagsException = TooManyTagsException$1;
 exports.UpdateCertificateOptionsCommand = UpdateCertificateOptionsCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.ValidationMethod = ValidationMethod;
 exports.paginateListCertificates = paginateListCertificates;
 exports.waitForCertificateValidated = waitForCertificateValidated;