@aws-sdk/client-acm 3.306.0 → 3.309.0

package/dist-es/protocols/Aws_json1_1.js

@@ -2,43 +2,43 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { ACMServiceException as __BaseException } from "../models/ACMServiceException";
 import { AccessDeniedException, ConflictException, InvalidArgsException, InvalidArnException, InvalidDomainValidationOptionsException, InvalidParameterException, InvalidStateException, InvalidTagException, LimitExceededException, RequestInProgressException, ResourceInUseException, ResourceNotFoundException, TagPolicyException, ThrottlingException, TooManyTagsException, ValidationException, } from "../models/models_0";
-export const serializeAws_json1_1AddTagsToCertificateCommand = async (input, context) => {
+export const se_AddTagsToCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.AddTagsToCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1AddTagsToCertificateRequest(input, context));
+    body = JSON.stringify(se_AddTagsToCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteCertificateCommand = async (input, context) => {
+export const se_DeleteCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.DeleteCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteCertificateRequest(input, context));
+    body = JSON.stringify(se_DeleteCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeCertificateCommand = async (input, context) => {
+export const se_DescribeCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.DescribeCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeCertificateRequest(input, context));
+    body = JSON.stringify(se_DescribeCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ExportCertificateCommand = async (input, context) => {
+export const se_ExportCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.ExportCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ExportCertificateRequest(input, context));
+    body = JSON.stringify(se_ExportCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetAccountConfigurationCommand = async (input, context) => {
+export const se_GetAccountConfigurationCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.GetAccountConfiguration",
@@ -46,99 +46,99 @@ export const serializeAws_json1_1GetAccountConfigurationCommand = async (input,
     const body = "{}";
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetCertificateCommand = async (input, context) => {
+export const se_GetCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.GetCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetCertificateRequest(input, context));
+    body = JSON.stringify(se_GetCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ImportCertificateCommand = async (input, context) => {
+export const se_ImportCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.ImportCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ImportCertificateRequest(input, context));
+    body = JSON.stringify(se_ImportCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListCertificatesCommand = async (input, context) => {
+export const se_ListCertificatesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.ListCertificates",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListCertificatesRequest(input, context));
+    body = JSON.stringify(se_ListCertificatesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListTagsForCertificateCommand = async (input, context) => {
+export const se_ListTagsForCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.ListTagsForCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListTagsForCertificateRequest(input, context));
+    body = JSON.stringify(se_ListTagsForCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutAccountConfigurationCommand = async (input, context) => {
+export const se_PutAccountConfigurationCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.PutAccountConfiguration",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutAccountConfigurationRequest(input, context));
+    body = JSON.stringify(se_PutAccountConfigurationRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1RemoveTagsFromCertificateCommand = async (input, context) => {
+export const se_RemoveTagsFromCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.RemoveTagsFromCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1RemoveTagsFromCertificateRequest(input, context));
+    body = JSON.stringify(se_RemoveTagsFromCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1RenewCertificateCommand = async (input, context) => {
+export const se_RenewCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.RenewCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1RenewCertificateRequest(input, context));
+    body = JSON.stringify(se_RenewCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1RequestCertificateCommand = async (input, context) => {
+export const se_RequestCertificateCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.RequestCertificate",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1RequestCertificateRequest(input, context));
+    body = JSON.stringify(se_RequestCertificateRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ResendValidationEmailCommand = async (input, context) => {
+export const se_ResendValidationEmailCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.ResendValidationEmail",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ResendValidationEmailRequest(input, context));
+    body = JSON.stringify(se_ResendValidationEmailRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UpdateCertificateOptionsCommand = async (input, context) => {
+export const se_UpdateCertificateOptionsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "CertificateManager.UpdateCertificateOptions",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UpdateCertificateOptionsRequest(input, context));
+    body = JSON.stringify(se_UpdateCertificateOptionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const deserializeAws_json1_1AddTagsToCertificateCommand = async (output, context) => {
+export const de_AddTagsToCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1AddTagsToCertificateCommandError(output, context);
+        return de_AddTagsToCertificateCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -146,7 +146,7 @@ export const deserializeAws_json1_1AddTagsToCertificateCommand = async (output,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1AddTagsToCertificateCommandError = async (output, context) => {
+const de_AddTagsToCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -155,25 +155,25 @@ const deserializeAws_json1_1AddTagsToCertificateCommandError = async (output, co
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.acm#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidTagException":
         case "com.amazonaws.acm#InvalidTagException":
-            throw await deserializeAws_json1_1InvalidTagExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTagExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "TagPolicyException":
         case "com.amazonaws.acm#TagPolicyException":
-            throw await deserializeAws_json1_1TagPolicyExceptionResponse(parsedOutput, context);
+            throw await de_TagPolicyExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.acm#ThrottlingException":
-            throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.acm#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -184,9 +184,9 @@ const deserializeAws_json1_1AddTagsToCertificateCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1DeleteCertificateCommand = async (output, context) => {
+export const de_DeleteCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteCertificateCommandError(output, context);
+        return de_DeleteCertificateCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -194,7 +194,7 @@ export const deserializeAws_json1_1DeleteCertificateCommand = async (output, con
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteCertificateCommandError = async (output, context) => {
+const de_DeleteCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -203,22 +203,22 @@ const deserializeAws_json1_1DeleteCertificateCommandError = async (output, conte
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.acm#AccessDeniedException":
-            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.acm#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "ResourceInUseException":
         case "com.amazonaws.acm#ResourceInUseException":
-            throw await deserializeAws_json1_1ResourceInUseExceptionResponse(parsedOutput, context);
+            throw await de_ResourceInUseExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.acm#ThrottlingException":
-            throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -229,20 +229,20 @@ const deserializeAws_json1_1DeleteCertificateCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1DescribeCertificateCommand = async (output, context) => {
+export const de_DescribeCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeCertificateCommandError(output, context);
+        return de_DescribeCertificateCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeCertificateResponse(data, context);
+    contents = de_DescribeCertificateResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeCertificateCommandError = async (output, context) => {
+const de_DescribeCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -251,10 +251,10 @@ const deserializeAws_json1_1DescribeCertificateCommandError = async (output, con
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -265,20 +265,20 @@ const deserializeAws_json1_1DescribeCertificateCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1ExportCertificateCommand = async (output, context) => {
+export const de_ExportCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ExportCertificateCommandError(output, context);
+        return de_ExportCertificateCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ExportCertificateResponse(data, context);
+    contents = de_ExportCertificateResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ExportCertificateCommandError = async (output, context) => {
+const de_ExportCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -287,13 +287,13 @@ const deserializeAws_json1_1ExportCertificateCommandError = async (output, conte
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "RequestInProgressException":
         case "com.amazonaws.acm#RequestInProgressException":
-            throw await deserializeAws_json1_1RequestInProgressExceptionResponse(parsedOutput, context);
+            throw await de_RequestInProgressExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -304,20 +304,20 @@ const deserializeAws_json1_1ExportCertificateCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1GetAccountConfigurationCommand = async (output, context) => {
+export const de_GetAccountConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetAccountConfigurationCommandError(output, context);
+        return de_GetAccountConfigurationCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetAccountConfigurationResponse(data, context);
+    contents = de_GetAccountConfigurationResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetAccountConfigurationCommandError = async (output, context) => {
+const de_GetAccountConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -326,10 +326,10 @@ const deserializeAws_json1_1GetAccountConfigurationCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.acm#AccessDeniedException":
-            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.acm#ThrottlingException":
-            throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -340,20 +340,20 @@ const deserializeAws_json1_1GetAccountConfigurationCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1GetCertificateCommand = async (output, context) => {
+export const de_GetCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetCertificateCommandError(output, context);
+        return de_GetCertificateCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetCertificateResponse(data, context);
+    contents = de_GetCertificateResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetCertificateCommandError = async (output, context) => {
+const de_GetCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -362,13 +362,13 @@ const deserializeAws_json1_1GetCertificateCommandError = async (output, context)
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "RequestInProgressException":
         case "com.amazonaws.acm#RequestInProgressException":
-            throw await deserializeAws_json1_1RequestInProgressExceptionResponse(parsedOutput, context);
+            throw await de_RequestInProgressExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -379,20 +379,20 @@ const deserializeAws_json1_1GetCertificateCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1ImportCertificateCommand = async (output, context) => {
+export const de_ImportCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ImportCertificateCommandError(output, context);
+        return de_ImportCertificateCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ImportCertificateResponse(data, context);
+    contents = de_ImportCertificateResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ImportCertificateCommandError = async (output, context) => {
+const de_ImportCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -401,25 +401,25 @@ const deserializeAws_json1_1ImportCertificateCommandError = async (output, conte
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.acm#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidTagException":
         case "com.amazonaws.acm#InvalidTagException":
-            throw await deserializeAws_json1_1InvalidTagExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTagExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.acm#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "TagPolicyException":
         case "com.amazonaws.acm#TagPolicyException":
-            throw await deserializeAws_json1_1TagPolicyExceptionResponse(parsedOutput, context);
+            throw await de_TagPolicyExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.acm#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -430,20 +430,20 @@ const deserializeAws_json1_1ImportCertificateCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1ListCertificatesCommand = async (output, context) => {
+export const de_ListCertificatesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListCertificatesCommandError(output, context);
+        return de_ListCertificatesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListCertificatesResponse(data, context);
+    contents = de_ListCertificatesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListCertificatesCommandError = async (output, context) => {
+const de_ListCertificatesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -452,10 +452,10 @@ const deserializeAws_json1_1ListCertificatesCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidArgsException":
         case "com.amazonaws.acm#InvalidArgsException":
-            throw await deserializeAws_json1_1InvalidArgsExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArgsExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.acm#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -466,20 +466,20 @@ const deserializeAws_json1_1ListCertificatesCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1ListTagsForCertificateCommand = async (output, context) => {
+export const de_ListTagsForCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListTagsForCertificateCommandError(output, context);
+        return de_ListTagsForCertificateCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListTagsForCertificateResponse(data, context);
+    contents = de_ListTagsForCertificateResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListTagsForCertificateCommandError = async (output, context) => {
+const de_ListTagsForCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -488,10 +488,10 @@ const deserializeAws_json1_1ListTagsForCertificateCommandError = async (output,
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -502,9 +502,9 @@ const deserializeAws_json1_1ListTagsForCertificateCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1PutAccountConfigurationCommand = async (output, context) => {
+export const de_PutAccountConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutAccountConfigurationCommandError(output, context);
+        return de_PutAccountConfigurationCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -512,7 +512,7 @@ export const deserializeAws_json1_1PutAccountConfigurationCommand = async (outpu
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutAccountConfigurationCommandError = async (output, context) => {
+const de_PutAccountConfigurationCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -521,16 +521,16 @@ const deserializeAws_json1_1PutAccountConfigurationCommandError = async (output,
     switch (errorCode) {
         case "AccessDeniedException":
         case "com.amazonaws.acm#AccessDeniedException":
-            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
         case "ConflictException":
         case "com.amazonaws.acm#ConflictException":
-            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+            throw await de_ConflictExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.acm#ThrottlingException":
-            throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "com.amazonaws.acm#ValidationException":
-            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+            throw await de_ValidationExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -541,9 +541,9 @@ const deserializeAws_json1_1PutAccountConfigurationCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1RemoveTagsFromCertificateCommand = async (output, context) => {
+export const de_RemoveTagsFromCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1RemoveTagsFromCertificateCommandError(output, context);
+        return de_RemoveTagsFromCertificateCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -551,7 +551,7 @@ export const deserializeAws_json1_1RemoveTagsFromCertificateCommand = async (out
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1RemoveTagsFromCertificateCommandError = async (output, context) => {
+const de_RemoveTagsFromCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -560,22 +560,22 @@ const deserializeAws_json1_1RemoveTagsFromCertificateCommandError = async (outpu
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.acm#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidTagException":
         case "com.amazonaws.acm#InvalidTagException":
-            throw await deserializeAws_json1_1InvalidTagExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTagExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         case "TagPolicyException":
         case "com.amazonaws.acm#TagPolicyException":
-            throw await deserializeAws_json1_1TagPolicyExceptionResponse(parsedOutput, context);
+            throw await de_TagPolicyExceptionRes(parsedOutput, context);
         case "ThrottlingException":
         case "com.amazonaws.acm#ThrottlingException":
-            throw await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context);
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -586,9 +586,9 @@ const deserializeAws_json1_1RemoveTagsFromCertificateCommandError = async (outpu
             });
     }
 };
-export const deserializeAws_json1_1RenewCertificateCommand = async (output, context) => {
+export const de_RenewCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1RenewCertificateCommandError(output, context);
+        return de_RenewCertificateCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -596,7 +596,7 @@ export const deserializeAws_json1_1RenewCertificateCommand = async (output, cont
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1RenewCertificateCommandError = async (output, context) => {
+const de_RenewCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -605,10 +605,10 @@ const deserializeAws_json1_1RenewCertificateCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -619,20 +619,20 @@ const deserializeAws_json1_1RenewCertificateCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1RequestCertificateCommand = async (output, context) => {
+export const de_RequestCertificateCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1RequestCertificateCommandError(output, context);
+        return de_RequestCertificateCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1RequestCertificateResponse(data, context);
+    contents = de_RequestCertificateResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1RequestCertificateCommandError = async (output, context) => {
+const de_RequestCertificateCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -641,25 +641,25 @@ const deserializeAws_json1_1RequestCertificateCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "InvalidDomainValidationOptionsException":
         case "com.amazonaws.acm#InvalidDomainValidationOptionsException":
-            throw await deserializeAws_json1_1InvalidDomainValidationOptionsExceptionResponse(parsedOutput, context);
+            throw await de_InvalidDomainValidationOptionsExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.acm#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidTagException":
         case "com.amazonaws.acm#InvalidTagException":
-            throw await deserializeAws_json1_1InvalidTagExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTagExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.acm#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "TagPolicyException":
         case "com.amazonaws.acm#TagPolicyException":
-            throw await deserializeAws_json1_1TagPolicyExceptionResponse(parsedOutput, context);
+            throw await de_TagPolicyExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.acm#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -670,9 +670,9 @@ const deserializeAws_json1_1RequestCertificateCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1ResendValidationEmailCommand = async (output, context) => {
+export const de_ResendValidationEmailCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ResendValidationEmailCommandError(output, context);
+        return de_ResendValidationEmailCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -680,7 +680,7 @@ export const deserializeAws_json1_1ResendValidationEmailCommand = async (output,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ResendValidationEmailCommandError = async (output, context) => {
+const de_ResendValidationEmailCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -689,16 +689,16 @@ const deserializeAws_json1_1ResendValidationEmailCommandError = async (output, c
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "InvalidDomainValidationOptionsException":
         case "com.amazonaws.acm#InvalidDomainValidationOptionsException":
-            throw await deserializeAws_json1_1InvalidDomainValidationOptionsExceptionResponse(parsedOutput, context);
+            throw await de_InvalidDomainValidationOptionsExceptionRes(parsedOutput, context);
         case "InvalidStateException":
         case "com.amazonaws.acm#InvalidStateException":
-            throw await deserializeAws_json1_1InvalidStateExceptionResponse(parsedOutput, context);
+            throw await de_InvalidStateExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -709,9 +709,9 @@ const deserializeAws_json1_1ResendValidationEmailCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1UpdateCertificateOptionsCommand = async (output, context) => {
+export const de_UpdateCertificateOptionsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UpdateCertificateOptionsCommandError(output, context);
+        return de_UpdateCertificateOptionsCommandError(output, context);
     }
     await collectBody(output.body, context);
     const response = {
@@ -719,7 +719,7 @@ export const deserializeAws_json1_1UpdateCertificateOptionsCommand = async (outp
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UpdateCertificateOptionsCommandError = async (output, context) => {
+const de_UpdateCertificateOptionsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -728,16 +728,16 @@ const deserializeAws_json1_1UpdateCertificateOptionsCommandError = async (output
     switch (errorCode) {
         case "InvalidArnException":
         case "com.amazonaws.acm#InvalidArnException":
-            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+            throw await de_InvalidArnExceptionRes(parsedOutput, context);
         case "InvalidStateException":
         case "com.amazonaws.acm#InvalidStateException":
-            throw await deserializeAws_json1_1InvalidStateExceptionResponse(parsedOutput, context);
+            throw await de_InvalidStateExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.acm#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ResourceNotFoundException":
         case "com.amazonaws.acm#ResourceNotFoundException":
-            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -748,428 +748,420 @@ const deserializeAws_json1_1UpdateCertificateOptionsCommandError = async (output
             });
     }
 };
-const deserializeAws_json1_1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1AccessDeniedException(body, context);
+    const deserialized = de_AccessDeniedException(body, context);
     const exception = new AccessDeniedException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ConflictExceptionResponse = async (parsedOutput, context) => {
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ConflictException(body, context);
+    const deserialized = de_ConflictException(body, context);
     const exception = new ConflictException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidArgsExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidArgsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidArgsException(body, context);
+    const deserialized = de_InvalidArgsException(body, context);
     const exception = new InvalidArgsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidArnExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidArnExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidArnException(body, context);
+    const deserialized = de_InvalidArnException(body, context);
     const exception = new InvalidArnException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidDomainValidationOptionsExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidDomainValidationOptionsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidDomainValidationOptionsException(body, context);
+    const deserialized = de_InvalidDomainValidationOptionsException(body, context);
     const exception = new InvalidDomainValidationOptionsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidParameterExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidParameterException(body, context);
+    const deserialized = de_InvalidParameterException(body, context);
     const exception = new InvalidParameterException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidStateExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidStateExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidStateException(body, context);
+    const deserialized = de_InvalidStateException(body, context);
     const exception = new InvalidStateException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidTagExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidTagExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidTagException(body, context);
+    const deserialized = de_InvalidTagException(body, context);
     const exception = new InvalidTagException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1LimitExceededExceptionResponse = async (parsedOutput, context) => {
+const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1LimitExceededException(body, context);
+    const deserialized = de_LimitExceededException(body, context);
     const exception = new LimitExceededException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1RequestInProgressExceptionResponse = async (parsedOutput, context) => {
+const de_RequestInProgressExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1RequestInProgressException(body, context);
+    const deserialized = de_RequestInProgressException(body, context);
     const exception = new RequestInProgressException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ResourceInUseExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceInUseExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ResourceInUseException(body, context);
+    const deserialized = de_ResourceInUseException(body, context);
     const exception = new ResourceInUseException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ResourceNotFoundException(body, context);
+    const deserialized = de_ResourceNotFoundException(body, context);
     const exception = new ResourceNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1TagPolicyExceptionResponse = async (parsedOutput, context) => {
+const de_TagPolicyExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1TagPolicyException(body, context);
+    const deserialized = de_TagPolicyException(body, context);
     const exception = new TagPolicyException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ThrottlingException(body, context);
+    const deserialized = de_ThrottlingException(body, context);
     const exception = new ThrottlingException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
+const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1TooManyTagsException(body, context);
+    const deserialized = de_TooManyTagsException(body, context);
     const exception = new TooManyTagsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ValidationExceptionResponse = async (parsedOutput, context) => {
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ValidationException(body, context);
+    const deserialized = de_ValidationException(body, context);
     const exception = new ValidationException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_json1_1AddTagsToCertificateRequest = (input, context) => {
+const se_AddTagsToCertificateRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
     };
 };
-const serializeAws_json1_1CertificateOptions = (input, context) => {
+const se_CertificateOptions = (input, context) => {
     return {
         ...(input.CertificateTransparencyLoggingPreference != null && {
             CertificateTransparencyLoggingPreference: input.CertificateTransparencyLoggingPreference,
         }),
     };
 };
-const serializeAws_json1_1CertificateStatuses = (input, context) => {
+const se_CertificateStatuses = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1DeleteCertificateRequest = (input, context) => {
+const se_DeleteCertificateRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
     };
 };
-const serializeAws_json1_1DescribeCertificateRequest = (input, context) => {
+const se_DescribeCertificateRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
     };
 };
-const serializeAws_json1_1DomainList = (input, context) => {
+const se_DomainList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1DomainValidationOption = (input, context) => {
+const se_DomainValidationOption = (input, context) => {
     return {
         ...(input.DomainName != null && { DomainName: input.DomainName }),
         ...(input.ValidationDomain != null && { ValidationDomain: input.ValidationDomain }),
     };
 };
-const serializeAws_json1_1DomainValidationOptionList = (input, context) => {
+const se_DomainValidationOptionList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1DomainValidationOption(entry, context);
+        return se_DomainValidationOption(entry, context);
     });
 };
-const serializeAws_json1_1ExpiryEventsConfiguration = (input, context) => {
+const se_ExpiryEventsConfiguration = (input, context) => {
     return {
         ...(input.DaysBeforeExpiry != null && { DaysBeforeExpiry: input.DaysBeforeExpiry }),
     };
 };
-const serializeAws_json1_1ExportCertificateRequest = (input, context) => {
+const se_ExportCertificateRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
         ...(input.Passphrase != null && { Passphrase: context.base64Encoder(input.Passphrase) }),
     };
 };
-const serializeAws_json1_1ExtendedKeyUsageFilterList = (input, context) => {
+const se_ExtendedKeyUsageFilterList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1Filters = (input, context) => {
+const se_Filters = (input, context) => {
     return {
         ...(input.extendedKeyUsage != null && {
-            extendedKeyUsage: serializeAws_json1_1ExtendedKeyUsageFilterList(input.extendedKeyUsage, context),
+            extendedKeyUsage: se_ExtendedKeyUsageFilterList(input.extendedKeyUsage, context),
         }),
-        ...(input.keyTypes != null && { keyTypes: serializeAws_json1_1KeyAlgorithmList(input.keyTypes, context) }),
-        ...(input.keyUsage != null && { keyUsage: serializeAws_json1_1KeyUsageFilterList(input.keyUsage, context) }),
+        ...(input.keyTypes != null && { keyTypes: se_KeyAlgorithmList(input.keyTypes, context) }),
+        ...(input.keyUsage != null && { keyUsage: se_KeyUsageFilterList(input.keyUsage, context) }),
     };
 };
-const serializeAws_json1_1GetCertificateRequest = (input, context) => {
+const se_GetCertificateRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
     };
 };
-const serializeAws_json1_1ImportCertificateRequest = (input, context) => {
+const se_ImportCertificateRequest = (input, context) => {
     return {
         ...(input.Certificate != null && { Certificate: context.base64Encoder(input.Certificate) }),
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
         ...(input.CertificateChain != null && { CertificateChain: context.base64Encoder(input.CertificateChain) }),
         ...(input.PrivateKey != null && { PrivateKey: context.base64Encoder(input.PrivateKey) }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
     };
 };
-const serializeAws_json1_1KeyAlgorithmList = (input, context) => {
+const se_KeyAlgorithmList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1KeyUsageFilterList = (input, context) => {
+const se_KeyUsageFilterList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ListCertificatesRequest = (input, context) => {
+const se_ListCertificatesRequest = (input, context) => {
     return {
         ...(input.CertificateStatuses != null && {
-            CertificateStatuses: serializeAws_json1_1CertificateStatuses(input.CertificateStatuses, context),
+            CertificateStatuses: se_CertificateStatuses(input.CertificateStatuses, context),
         }),
-        ...(input.Includes != null && { Includes: serializeAws_json1_1Filters(input.Includes, context) }),
+        ...(input.Includes != null && { Includes: se_Filters(input.Includes, context) }),
         ...(input.MaxItems != null && { MaxItems: input.MaxItems }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
         ...(input.SortBy != null && { SortBy: input.SortBy }),
         ...(input.SortOrder != null && { SortOrder: input.SortOrder }),
     };
 };
-const serializeAws_json1_1ListTagsForCertificateRequest = (input, context) => {
+const se_ListTagsForCertificateRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
     };
 };
-const serializeAws_json1_1PutAccountConfigurationRequest = (input, context) => {
+const se_PutAccountConfigurationRequest = (input, context) => {
     return {
-        ...(input.ExpiryEvents != null && {
-            ExpiryEvents: serializeAws_json1_1ExpiryEventsConfiguration(input.ExpiryEvents, context),
-        }),
+        ...(input.ExpiryEvents != null && { ExpiryEvents: se_ExpiryEventsConfiguration(input.ExpiryEvents, context) }),
         ...(input.IdempotencyToken != null && { IdempotencyToken: input.IdempotencyToken }),
     };
 };
-const serializeAws_json1_1RemoveTagsFromCertificateRequest = (input, context) => {
+const se_RemoveTagsFromCertificateRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
     };
 };
-const serializeAws_json1_1RenewCertificateRequest = (input, context) => {
+const se_RenewCertificateRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
     };
 };
-const serializeAws_json1_1RequestCertificateRequest = (input, context) => {
+const se_RequestCertificateRequest = (input, context) => {
     return {
         ...(input.CertificateAuthorityArn != null && { CertificateAuthorityArn: input.CertificateAuthorityArn }),
         ...(input.DomainName != null && { DomainName: input.DomainName }),
         ...(input.DomainValidationOptions != null && {
-            DomainValidationOptions: serializeAws_json1_1DomainValidationOptionList(input.DomainValidationOptions, context),
+            DomainValidationOptions: se_DomainValidationOptionList(input.DomainValidationOptions, context),
         }),
         ...(input.IdempotencyToken != null && { IdempotencyToken: input.IdempotencyToken }),
         ...(input.KeyAlgorithm != null && { KeyAlgorithm: input.KeyAlgorithm }),
-        ...(input.Options != null && { Options: serializeAws_json1_1CertificateOptions(input.Options, context) }),
+        ...(input.Options != null && { Options: se_CertificateOptions(input.Options, context) }),
         ...(input.SubjectAlternativeNames != null && {
-            SubjectAlternativeNames: serializeAws_json1_1DomainList(input.SubjectAlternativeNames, context),
+            SubjectAlternativeNames: se_DomainList(input.SubjectAlternativeNames, context),
         }),
-        ...(input.Tags != null && { Tags: serializeAws_json1_1TagList(input.Tags, context) }),
+        ...(input.Tags != null && { Tags: se_TagList(input.Tags, context) }),
         ...(input.ValidationMethod != null && { ValidationMethod: input.ValidationMethod }),
     };
 };
-const serializeAws_json1_1ResendValidationEmailRequest = (input, context) => {
+const se_ResendValidationEmailRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
         ...(input.Domain != null && { Domain: input.Domain }),
         ...(input.ValidationDomain != null && { ValidationDomain: input.ValidationDomain }),
     };
 };
-const serializeAws_json1_1Tag = (input, context) => {
+const se_Tag = (input, context) => {
     return {
         ...(input.Key != null && { Key: input.Key }),
         ...(input.Value != null && { Value: input.Value }),
     };
 };
-const serializeAws_json1_1TagList = (input, context) => {
+const se_TagList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1Tag(entry, context);
+        return se_Tag(entry, context);
     });
 };
-const serializeAws_json1_1UpdateCertificateOptionsRequest = (input, context) => {
+const se_UpdateCertificateOptionsRequest = (input, context) => {
     return {
         ...(input.CertificateArn != null && { CertificateArn: input.CertificateArn }),
-        ...(input.Options != null && { Options: serializeAws_json1_1CertificateOptions(input.Options, context) }),
+        ...(input.Options != null && { Options: se_CertificateOptions(input.Options, context) }),
     };
 };
-const deserializeAws_json1_1AccessDeniedException = (output, context) => {
+const de_AccessDeniedException = (output, context) => {
     return {
         Message: __expectString(output.Message),
     };
 };
-const deserializeAws_json1_1CertificateDetail = (output, context) => {
+const de_CertificateDetail = (output, context) => {
     return {
         CertificateArn: __expectString(output.CertificateArn),
         CertificateAuthorityArn: __expectString(output.CertificateAuthorityArn),
         CreatedAt: output.CreatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreatedAt))) : undefined,
         DomainName: __expectString(output.DomainName),
         DomainValidationOptions: output.DomainValidationOptions != null
-            ? deserializeAws_json1_1DomainValidationList(output.DomainValidationOptions, context)
-            : undefined,
-        ExtendedKeyUsages: output.ExtendedKeyUsages != null
-            ? deserializeAws_json1_1ExtendedKeyUsageList(output.ExtendedKeyUsages, context)
+            ? de_DomainValidationList(output.DomainValidationOptions, context)
             : undefined,
+        ExtendedKeyUsages: output.ExtendedKeyUsages != null ? de_ExtendedKeyUsageList(output.ExtendedKeyUsages, context) : undefined,
         FailureReason: __expectString(output.FailureReason),
         ImportedAt: output.ImportedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.ImportedAt))) : undefined,
-        InUseBy: output.InUseBy != null ? deserializeAws_json1_1InUseList(output.InUseBy, context) : undefined,
+        InUseBy: output.InUseBy != null ? de_InUseList(output.InUseBy, context) : undefined,
         IssuedAt: output.IssuedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.IssuedAt))) : undefined,
         Issuer: __expectString(output.Issuer),
         KeyAlgorithm: __expectString(output.KeyAlgorithm),
-        KeyUsages: output.KeyUsages != null ? deserializeAws_json1_1KeyUsageList(output.KeyUsages, context) : undefined,
+        KeyUsages: output.KeyUsages != null ? de_KeyUsageList(output.KeyUsages, context) : undefined,
         NotAfter: output.NotAfter != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.NotAfter))) : undefined,
         NotBefore: output.NotBefore != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.NotBefore))) : undefined,
-        Options: output.Options != null ? deserializeAws_json1_1CertificateOptions(output.Options, context) : undefined,
+        Options: output.Options != null ? de_CertificateOptions(output.Options, context) : undefined,
         RenewalEligibility: __expectString(output.RenewalEligibility),
-        RenewalSummary: output.RenewalSummary != null ? deserializeAws_json1_1RenewalSummary(output.RenewalSummary, context) : undefined,
+        RenewalSummary: output.RenewalSummary != null ? de_RenewalSummary(output.RenewalSummary, context) : undefined,
         RevocationReason: __expectString(output.RevocationReason),
         RevokedAt: output.RevokedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.RevokedAt))) : undefined,
         Serial: __expectString(output.Serial),
         SignatureAlgorithm: __expectString(output.SignatureAlgorithm),
         Status: __expectString(output.Status),
         Subject: __expectString(output.Subject),
-        SubjectAlternativeNames: output.SubjectAlternativeNames != null
-            ? deserializeAws_json1_1DomainList(output.SubjectAlternativeNames, context)
-            : undefined,
+        SubjectAlternativeNames: output.SubjectAlternativeNames != null ? de_DomainList(output.SubjectAlternativeNames, context) : undefined,
         Type: __expectString(output.Type),
     };
 };
-const deserializeAws_json1_1CertificateOptions = (output, context) => {
+const de_CertificateOptions = (output, context) => {
     return {
         CertificateTransparencyLoggingPreference: __expectString(output.CertificateTransparencyLoggingPreference),
     };
 };
-const deserializeAws_json1_1CertificateSummary = (output, context) => {
+const de_CertificateSummary = (output, context) => {
     return {
         CertificateArn: __expectString(output.CertificateArn),
         CreatedAt: output.CreatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreatedAt))) : undefined,
         DomainName: __expectString(output.DomainName),
         Exported: __expectBoolean(output.Exported),
-        ExtendedKeyUsages: output.ExtendedKeyUsages != null
-            ? deserializeAws_json1_1ExtendedKeyUsageNames(output.ExtendedKeyUsages, context)
-            : undefined,
+        ExtendedKeyUsages: output.ExtendedKeyUsages != null ? de_ExtendedKeyUsageNames(output.ExtendedKeyUsages, context) : undefined,
         HasAdditionalSubjectAlternativeNames: __expectBoolean(output.HasAdditionalSubjectAlternativeNames),
         ImportedAt: output.ImportedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.ImportedAt))) : undefined,
         InUse: __expectBoolean(output.InUse),
         IssuedAt: output.IssuedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.IssuedAt))) : undefined,
         KeyAlgorithm: __expectString(output.KeyAlgorithm),
-        KeyUsages: output.KeyUsages != null ? deserializeAws_json1_1KeyUsageNames(output.KeyUsages, context) : undefined,
+        KeyUsages: output.KeyUsages != null ? de_KeyUsageNames(output.KeyUsages, context) : undefined,
         NotAfter: output.NotAfter != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.NotAfter))) : undefined,
         NotBefore: output.NotBefore != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.NotBefore))) : undefined,
         RenewalEligibility: __expectString(output.RenewalEligibility),
         RevokedAt: output.RevokedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.RevokedAt))) : undefined,
         Status: __expectString(output.Status),
         SubjectAlternativeNameSummaries: output.SubjectAlternativeNameSummaries != null
-            ? deserializeAws_json1_1DomainList(output.SubjectAlternativeNameSummaries, context)
+            ? de_DomainList(output.SubjectAlternativeNameSummaries, context)
             : undefined,
         Type: __expectString(output.Type),
     };
 };
-const deserializeAws_json1_1CertificateSummaryList = (output, context) => {
+const de_CertificateSummaryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1CertificateSummary(entry, context);
+        return de_CertificateSummary(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ConflictException = (output, context) => {
+const de_ConflictException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1DescribeCertificateResponse = (output, context) => {
+const de_DescribeCertificateResponse = (output, context) => {
     return {
-        Certificate: output.Certificate != null ? deserializeAws_json1_1CertificateDetail(output.Certificate, context) : undefined,
+        Certificate: output.Certificate != null ? de_CertificateDetail(output.Certificate, context) : undefined,
     };
 };
-const deserializeAws_json1_1DomainList = (output, context) => {
+const de_DomainList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1180,59 +1172,57 @@ const deserializeAws_json1_1DomainList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1DomainValidation = (output, context) => {
+const de_DomainValidation = (output, context) => {
     return {
         DomainName: __expectString(output.DomainName),
-        ResourceRecord: output.ResourceRecord != null ? deserializeAws_json1_1ResourceRecord(output.ResourceRecord, context) : undefined,
+        ResourceRecord: output.ResourceRecord != null ? de_ResourceRecord(output.ResourceRecord, context) : undefined,
         ValidationDomain: __expectString(output.ValidationDomain),
-        ValidationEmails: output.ValidationEmails != null
-            ? deserializeAws_json1_1ValidationEmailList(output.ValidationEmails, context)
-            : undefined,
+        ValidationEmails: output.ValidationEmails != null ? de_ValidationEmailList(output.ValidationEmails, context) : undefined,
         ValidationMethod: __expectString(output.ValidationMethod),
         ValidationStatus: __expectString(output.ValidationStatus),
     };
 };
-const deserializeAws_json1_1DomainValidationList = (output, context) => {
+const de_DomainValidationList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1DomainValidation(entry, context);
+        return de_DomainValidation(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ExpiryEventsConfiguration = (output, context) => {
+const de_ExpiryEventsConfiguration = (output, context) => {
     return {
         DaysBeforeExpiry: __expectInt32(output.DaysBeforeExpiry),
     };
 };
-const deserializeAws_json1_1ExportCertificateResponse = (output, context) => {
+const de_ExportCertificateResponse = (output, context) => {
     return {
         Certificate: __expectString(output.Certificate),
         CertificateChain: __expectString(output.CertificateChain),
         PrivateKey: __expectString(output.PrivateKey),
     };
 };
-const deserializeAws_json1_1ExtendedKeyUsage = (output, context) => {
+const de_ExtendedKeyUsage = (output, context) => {
     return {
         Name: __expectString(output.Name),
         OID: __expectString(output.OID),
     };
 };
-const deserializeAws_json1_1ExtendedKeyUsageList = (output, context) => {
+const de_ExtendedKeyUsageList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ExtendedKeyUsage(entry, context);
+        return de_ExtendedKeyUsage(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ExtendedKeyUsageNames = (output, context) => {
+const de_ExtendedKeyUsageNames = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1243,25 +1233,23 @@ const deserializeAws_json1_1ExtendedKeyUsageNames = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1GetAccountConfigurationResponse = (output, context) => {
+const de_GetAccountConfigurationResponse = (output, context) => {
     return {
-        ExpiryEvents: output.ExpiryEvents != null
-            ? deserializeAws_json1_1ExpiryEventsConfiguration(output.ExpiryEvents, context)
-            : undefined,
+        ExpiryEvents: output.ExpiryEvents != null ? de_ExpiryEventsConfiguration(output.ExpiryEvents, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetCertificateResponse = (output, context) => {
+const de_GetCertificateResponse = (output, context) => {
     return {
         Certificate: __expectString(output.Certificate),
         CertificateChain: __expectString(output.CertificateChain),
     };
 };
-const deserializeAws_json1_1ImportCertificateResponse = (output, context) => {
+const de_ImportCertificateResponse = (output, context) => {
     return {
         CertificateArn: __expectString(output.CertificateArn),
     };
 };
-const deserializeAws_json1_1InUseList = (output, context) => {
+const de_InUseList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1272,53 +1260,53 @@ const deserializeAws_json1_1InUseList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1InvalidArgsException = (output, context) => {
+const de_InvalidArgsException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidArnException = (output, context) => {
+const de_InvalidArnException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidDomainValidationOptionsException = (output, context) => {
+const de_InvalidDomainValidationOptionsException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidParameterException = (output, context) => {
+const de_InvalidParameterException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidStateException = (output, context) => {
+const de_InvalidStateException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidTagException = (output, context) => {
+const de_InvalidTagException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1KeyUsage = (output, context) => {
+const de_KeyUsage = (output, context) => {
     return {
         Name: __expectString(output.Name),
     };
 };
-const deserializeAws_json1_1KeyUsageList = (output, context) => {
+const de_KeyUsageList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1KeyUsage(entry, context);
+        return de_KeyUsage(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1KeyUsageNames = (output, context) => {
+const de_KeyUsageNames = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1329,94 +1317,94 @@ const deserializeAws_json1_1KeyUsageNames = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1LimitExceededException = (output, context) => {
+const de_LimitExceededException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ListCertificatesResponse = (output, context) => {
+const de_ListCertificatesResponse = (output, context) => {
     return {
         CertificateSummaryList: output.CertificateSummaryList != null
-            ? deserializeAws_json1_1CertificateSummaryList(output.CertificateSummaryList, context)
+            ? de_CertificateSummaryList(output.CertificateSummaryList, context)
             : undefined,
         NextToken: __expectString(output.NextToken),
     };
 };
-const deserializeAws_json1_1ListTagsForCertificateResponse = (output, context) => {
+const de_ListTagsForCertificateResponse = (output, context) => {
     return {
-        Tags: output.Tags != null ? deserializeAws_json1_1TagList(output.Tags, context) : undefined,
+        Tags: output.Tags != null ? de_TagList(output.Tags, context) : undefined,
     };
 };
-const deserializeAws_json1_1RenewalSummary = (output, context) => {
+const de_RenewalSummary = (output, context) => {
     return {
         DomainValidationOptions: output.DomainValidationOptions != null
-            ? deserializeAws_json1_1DomainValidationList(output.DomainValidationOptions, context)
+            ? de_DomainValidationList(output.DomainValidationOptions, context)
             : undefined,
         RenewalStatus: __expectString(output.RenewalStatus),
         RenewalStatusReason: __expectString(output.RenewalStatusReason),
         UpdatedAt: output.UpdatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.UpdatedAt))) : undefined,
     };
 };
-const deserializeAws_json1_1RequestCertificateResponse = (output, context) => {
+const de_RequestCertificateResponse = (output, context) => {
     return {
         CertificateArn: __expectString(output.CertificateArn),
     };
 };
-const deserializeAws_json1_1RequestInProgressException = (output, context) => {
+const de_RequestInProgressException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ResourceInUseException = (output, context) => {
+const de_ResourceInUseException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ResourceNotFoundException = (output, context) => {
+const de_ResourceNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ResourceRecord = (output, context) => {
+const de_ResourceRecord = (output, context) => {
     return {
         Name: __expectString(output.Name),
         Type: __expectString(output.Type),
         Value: __expectString(output.Value),
     };
 };
-const deserializeAws_json1_1Tag = (output, context) => {
+const de_Tag = (output, context) => {
     return {
         Key: __expectString(output.Key),
         Value: __expectString(output.Value),
     };
 };
-const deserializeAws_json1_1TagList = (output, context) => {
+const de_TagList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Tag(entry, context);
+        return de_Tag(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1TagPolicyException = (output, context) => {
+const de_TagPolicyException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ThrottlingException = (output, context) => {
+const de_ThrottlingException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1TooManyTagsException = (output, context) => {
+const de_TooManyTagsException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ValidationEmailList = (output, context) => {
+const de_ValidationEmailList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1427,7 +1415,7 @@ const deserializeAws_json1_1ValidationEmailList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1ValidationException = (output, context) => {
+const de_ValidationException = (output, context) => {
     return {
         message: __expectString(output.message),
     };