@aws-sdk/client-ecr-public 3.303.0 → 3.309.0

package/dist-es/protocols/Aws_json1_1.js

@@ -2,227 +2,227 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { ECRPUBLICServiceException as __BaseException } from "../models/ECRPUBLICServiceException";
 import { EmptyUploadException, ImageAlreadyExistsException, ImageDigestDoesNotMatchException, ImageNotFoundException, ImageTagAlreadyExistsException, InvalidLayerException, InvalidLayerPartException, InvalidParameterException, InvalidTagParameterException, LayerAlreadyExistsException, LayerPartTooSmallException, LayersNotFoundException, LimitExceededException, ReferencedImagesNotFoundException, RegistryNotFoundException, RepositoryAlreadyExistsException, RepositoryCatalogDataNotFoundException, RepositoryNotEmptyException, RepositoryNotFoundException, RepositoryPolicyNotFoundException, ServerException, TooManyTagsException, UnsupportedCommandException, UploadNotFoundException, } from "../models/models_0";
-export const serializeAws_json1_1BatchCheckLayerAvailabilityCommand = async (input, context) => {
+export const se_BatchCheckLayerAvailabilityCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.BatchCheckLayerAvailability",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1BatchCheckLayerAvailabilityRequest(input, context));
+    body = JSON.stringify(se_BatchCheckLayerAvailabilityRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1BatchDeleteImageCommand = async (input, context) => {
+export const se_BatchDeleteImageCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.BatchDeleteImage",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1BatchDeleteImageRequest(input, context));
+    body = JSON.stringify(se_BatchDeleteImageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CompleteLayerUploadCommand = async (input, context) => {
+export const se_CompleteLayerUploadCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.CompleteLayerUpload",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CompleteLayerUploadRequest(input, context));
+    body = JSON.stringify(se_CompleteLayerUploadRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1CreateRepositoryCommand = async (input, context) => {
+export const se_CreateRepositoryCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.CreateRepository",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1CreateRepositoryRequest(input, context));
+    body = JSON.stringify(se_CreateRepositoryRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteRepositoryCommand = async (input, context) => {
+export const se_DeleteRepositoryCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.DeleteRepository",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteRepositoryRequest(input, context));
+    body = JSON.stringify(se_DeleteRepositoryRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DeleteRepositoryPolicyCommand = async (input, context) => {
+export const se_DeleteRepositoryPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.DeleteRepositoryPolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DeleteRepositoryPolicyRequest(input, context));
+    body = JSON.stringify(se_DeleteRepositoryPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeImagesCommand = async (input, context) => {
+export const se_DescribeImagesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.DescribeImages",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeImagesRequest(input, context));
+    body = JSON.stringify(se_DescribeImagesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeImageTagsCommand = async (input, context) => {
+export const se_DescribeImageTagsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.DescribeImageTags",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeImageTagsRequest(input, context));
+    body = JSON.stringify(se_DescribeImageTagsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeRegistriesCommand = async (input, context) => {
+export const se_DescribeRegistriesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.DescribeRegistries",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeRegistriesRequest(input, context));
+    body = JSON.stringify(se_DescribeRegistriesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1DescribeRepositoriesCommand = async (input, context) => {
+export const se_DescribeRepositoriesCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.DescribeRepositories",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1DescribeRepositoriesRequest(input, context));
+    body = JSON.stringify(se_DescribeRepositoriesRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetAuthorizationTokenCommand = async (input, context) => {
+export const se_GetAuthorizationTokenCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.GetAuthorizationToken",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetAuthorizationTokenRequest(input, context));
+    body = JSON.stringify(se_GetAuthorizationTokenRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetRegistryCatalogDataCommand = async (input, context) => {
+export const se_GetRegistryCatalogDataCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.GetRegistryCatalogData",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetRegistryCatalogDataRequest(input, context));
+    body = JSON.stringify(se_GetRegistryCatalogDataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetRepositoryCatalogDataCommand = async (input, context) => {
+export const se_GetRepositoryCatalogDataCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.GetRepositoryCatalogData",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetRepositoryCatalogDataRequest(input, context));
+    body = JSON.stringify(se_GetRepositoryCatalogDataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1GetRepositoryPolicyCommand = async (input, context) => {
+export const se_GetRepositoryPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.GetRepositoryPolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1GetRepositoryPolicyRequest(input, context));
+    body = JSON.stringify(se_GetRepositoryPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1InitiateLayerUploadCommand = async (input, context) => {
+export const se_InitiateLayerUploadCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.InitiateLayerUpload",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1InitiateLayerUploadRequest(input, context));
+    body = JSON.stringify(se_InitiateLayerUploadRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1ListTagsForResourceCommand = async (input, context) => {
+export const se_ListTagsForResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.ListTagsForResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
+    body = JSON.stringify(se_ListTagsForResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutImageCommand = async (input, context) => {
+export const se_PutImageCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.PutImage",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutImageRequest(input, context));
+    body = JSON.stringify(se_PutImageRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutRegistryCatalogDataCommand = async (input, context) => {
+export const se_PutRegistryCatalogDataCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.PutRegistryCatalogData",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutRegistryCatalogDataRequest(input, context));
+    body = JSON.stringify(se_PutRegistryCatalogDataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1PutRepositoryCatalogDataCommand = async (input, context) => {
+export const se_PutRepositoryCatalogDataCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.PutRepositoryCatalogData",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1PutRepositoryCatalogDataRequest(input, context));
+    body = JSON.stringify(se_PutRepositoryCatalogDataRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1SetRepositoryPolicyCommand = async (input, context) => {
+export const se_SetRepositoryPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.SetRepositoryPolicy",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1SetRepositoryPolicyRequest(input, context));
+    body = JSON.stringify(se_SetRepositoryPolicyRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1TagResourceCommand = async (input, context) => {
+export const se_TagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.TagResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1TagResourceRequest(input, context));
+    body = JSON.stringify(se_TagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UntagResourceCommand = async (input, context) => {
+export const se_UntagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.UntagResource",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UntagResourceRequest(input, context));
+    body = JSON.stringify(se_UntagResourceRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const serializeAws_json1_1UploadLayerPartCommand = async (input, context) => {
+export const se_UploadLayerPartCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
         "x-amz-target": "SpencerFrontendService.UploadLayerPart",
     };
     let body;
-    body = JSON.stringify(serializeAws_json1_1UploadLayerPartRequest(input, context));
+    body = JSON.stringify(se_UploadLayerPartRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
-export const deserializeAws_json1_1BatchCheckLayerAvailabilityCommand = async (output, context) => {
+export const de_BatchCheckLayerAvailabilityCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1BatchCheckLayerAvailabilityCommandError(output, context);
+        return de_BatchCheckLayerAvailabilityCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1BatchCheckLayerAvailabilityResponse(data, context);
+    contents = de_BatchCheckLayerAvailabilityResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1BatchCheckLayerAvailabilityCommandError = async (output, context) => {
+const de_BatchCheckLayerAvailabilityCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -231,19 +231,19 @@ const deserializeAws_json1_1BatchCheckLayerAvailabilityCommandError = async (out
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RegistryNotFoundException":
         case "com.amazonaws.ecrpublic#RegistryNotFoundException":
-            throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RegistryNotFoundExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -254,20 +254,20 @@ const deserializeAws_json1_1BatchCheckLayerAvailabilityCommandError = async (out
             });
     }
 };
-export const deserializeAws_json1_1BatchDeleteImageCommand = async (output, context) => {
+export const de_BatchDeleteImageCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1BatchDeleteImageCommandError(output, context);
+        return de_BatchDeleteImageCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1BatchDeleteImageResponse(data, context);
+    contents = de_BatchDeleteImageResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1BatchDeleteImageCommandError = async (output, context) => {
+const de_BatchDeleteImageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -276,16 +276,16 @@ const deserializeAws_json1_1BatchDeleteImageCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -296,20 +296,20 @@ const deserializeAws_json1_1BatchDeleteImageCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1CompleteLayerUploadCommand = async (output, context) => {
+export const de_CompleteLayerUploadCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CompleteLayerUploadCommandError(output, context);
+        return de_CompleteLayerUploadCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CompleteLayerUploadResponse(data, context);
+    contents = de_CompleteLayerUploadResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CompleteLayerUploadCommandError = async (output, context) => {
+const de_CompleteLayerUploadCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -318,34 +318,34 @@ const deserializeAws_json1_1CompleteLayerUploadCommandError = async (output, con
     switch (errorCode) {
         case "EmptyUploadException":
         case "com.amazonaws.ecrpublic#EmptyUploadException":
-            throw await deserializeAws_json1_1EmptyUploadExceptionResponse(parsedOutput, context);
+            throw await de_EmptyUploadExceptionRes(parsedOutput, context);
         case "InvalidLayerException":
         case "com.amazonaws.ecrpublic#InvalidLayerException":
-            throw await deserializeAws_json1_1InvalidLayerExceptionResponse(parsedOutput, context);
+            throw await de_InvalidLayerExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LayerAlreadyExistsException":
         case "com.amazonaws.ecrpublic#LayerAlreadyExistsException":
-            throw await deserializeAws_json1_1LayerAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_LayerAlreadyExistsExceptionRes(parsedOutput, context);
         case "LayerPartTooSmallException":
         case "com.amazonaws.ecrpublic#LayerPartTooSmallException":
-            throw await deserializeAws_json1_1LayerPartTooSmallExceptionResponse(parsedOutput, context);
+            throw await de_LayerPartTooSmallExceptionRes(parsedOutput, context);
         case "RegistryNotFoundException":
         case "com.amazonaws.ecrpublic#RegistryNotFoundException":
-            throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RegistryNotFoundExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         case "UploadNotFoundException":
         case "com.amazonaws.ecrpublic#UploadNotFoundException":
-            throw await deserializeAws_json1_1UploadNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_UploadNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -356,20 +356,20 @@ const deserializeAws_json1_1CompleteLayerUploadCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1CreateRepositoryCommand = async (output, context) => {
+export const de_CreateRepositoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1CreateRepositoryCommandError(output, context);
+        return de_CreateRepositoryCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1CreateRepositoryResponse(data, context);
+    contents = de_CreateRepositoryResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1CreateRepositoryCommandError = async (output, context) => {
+const de_CreateRepositoryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -378,25 +378,25 @@ const deserializeAws_json1_1CreateRepositoryCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidTagParameterException":
         case "com.amazonaws.ecrpublic#InvalidTagParameterException":
-            throw await deserializeAws_json1_1InvalidTagParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTagParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.ecrpublic#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "RepositoryAlreadyExistsException":
         case "com.amazonaws.ecrpublic#RepositoryAlreadyExistsException":
-            throw await deserializeAws_json1_1RepositoryAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryAlreadyExistsExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.ecrpublic#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -407,20 +407,20 @@ const deserializeAws_json1_1CreateRepositoryCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1DeleteRepositoryCommand = async (output, context) => {
+export const de_DeleteRepositoryCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteRepositoryCommandError(output, context);
+        return de_DeleteRepositoryCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteRepositoryResponse(data, context);
+    contents = de_DeleteRepositoryResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteRepositoryCommandError = async (output, context) => {
+const de_DeleteRepositoryCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -429,19 +429,19 @@ const deserializeAws_json1_1DeleteRepositoryCommandError = async (output, contex
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotEmptyException":
         case "com.amazonaws.ecrpublic#RepositoryNotEmptyException":
-            throw await deserializeAws_json1_1RepositoryNotEmptyExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotEmptyExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -452,20 +452,20 @@ const deserializeAws_json1_1DeleteRepositoryCommandError = async (output, contex
             });
     }
 };
-export const deserializeAws_json1_1DeleteRepositoryPolicyCommand = async (output, context) => {
+export const de_DeleteRepositoryPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DeleteRepositoryPolicyCommandError(output, context);
+        return de_DeleteRepositoryPolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DeleteRepositoryPolicyResponse(data, context);
+    contents = de_DeleteRepositoryPolicyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DeleteRepositoryPolicyCommandError = async (output, context) => {
+const de_DeleteRepositoryPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -474,19 +474,19 @@ const deserializeAws_json1_1DeleteRepositoryPolicyCommandError = async (output,
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "RepositoryPolicyNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryPolicyNotFoundException":
-            throw await deserializeAws_json1_1RepositoryPolicyNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryPolicyNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -497,20 +497,20 @@ const deserializeAws_json1_1DeleteRepositoryPolicyCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1DescribeImagesCommand = async (output, context) => {
+export const de_DescribeImagesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeImagesCommandError(output, context);
+        return de_DescribeImagesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeImagesResponse(data, context);
+    contents = de_DescribeImagesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeImagesCommandError = async (output, context) => {
+const de_DescribeImagesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -519,19 +519,19 @@ const deserializeAws_json1_1DescribeImagesCommandError = async (output, context)
     switch (errorCode) {
         case "ImageNotFoundException":
         case "com.amazonaws.ecrpublic#ImageNotFoundException":
-            throw await deserializeAws_json1_1ImageNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ImageNotFoundExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -542,20 +542,20 @@ const deserializeAws_json1_1DescribeImagesCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1DescribeImageTagsCommand = async (output, context) => {
+export const de_DescribeImageTagsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeImageTagsCommandError(output, context);
+        return de_DescribeImageTagsCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeImageTagsResponse(data, context);
+    contents = de_DescribeImageTagsResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeImageTagsCommandError = async (output, context) => {
+const de_DescribeImageTagsCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -564,16 +564,16 @@ const deserializeAws_json1_1DescribeImageTagsCommandError = async (output, conte
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -584,20 +584,20 @@ const deserializeAws_json1_1DescribeImageTagsCommandError = async (output, conte
             });
     }
 };
-export const deserializeAws_json1_1DescribeRegistriesCommand = async (output, context) => {
+export const de_DescribeRegistriesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeRegistriesCommandError(output, context);
+        return de_DescribeRegistriesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeRegistriesResponse(data, context);
+    contents = de_DescribeRegistriesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeRegistriesCommandError = async (output, context) => {
+const de_DescribeRegistriesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -606,13 +606,13 @@ const deserializeAws_json1_1DescribeRegistriesCommandError = async (output, cont
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -623,20 +623,20 @@ const deserializeAws_json1_1DescribeRegistriesCommandError = async (output, cont
             });
     }
 };
-export const deserializeAws_json1_1DescribeRepositoriesCommand = async (output, context) => {
+export const de_DescribeRepositoriesCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1DescribeRepositoriesCommandError(output, context);
+        return de_DescribeRepositoriesCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1DescribeRepositoriesResponse(data, context);
+    contents = de_DescribeRepositoriesResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1DescribeRepositoriesCommandError = async (output, context) => {
+const de_DescribeRepositoriesCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -645,16 +645,16 @@ const deserializeAws_json1_1DescribeRepositoriesCommandError = async (output, co
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -665,20 +665,20 @@ const deserializeAws_json1_1DescribeRepositoriesCommandError = async (output, co
             });
     }
 };
-export const deserializeAws_json1_1GetAuthorizationTokenCommand = async (output, context) => {
+export const de_GetAuthorizationTokenCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetAuthorizationTokenCommandError(output, context);
+        return de_GetAuthorizationTokenCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetAuthorizationTokenResponse(data, context);
+    contents = de_GetAuthorizationTokenResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetAuthorizationTokenCommandError = async (output, context) => {
+const de_GetAuthorizationTokenCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -687,13 +687,13 @@ const deserializeAws_json1_1GetAuthorizationTokenCommandError = async (output, c
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -704,20 +704,20 @@ const deserializeAws_json1_1GetAuthorizationTokenCommandError = async (output, c
             });
     }
 };
-export const deserializeAws_json1_1GetRegistryCatalogDataCommand = async (output, context) => {
+export const de_GetRegistryCatalogDataCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetRegistryCatalogDataCommandError(output, context);
+        return de_GetRegistryCatalogDataCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetRegistryCatalogDataResponse(data, context);
+    contents = de_GetRegistryCatalogDataResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetRegistryCatalogDataCommandError = async (output, context) => {
+const de_GetRegistryCatalogDataCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -726,10 +726,10 @@ const deserializeAws_json1_1GetRegistryCatalogDataCommandError = async (output,
     switch (errorCode) {
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -740,20 +740,20 @@ const deserializeAws_json1_1GetRegistryCatalogDataCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1GetRepositoryCatalogDataCommand = async (output, context) => {
+export const de_GetRepositoryCatalogDataCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetRepositoryCatalogDataCommandError(output, context);
+        return de_GetRepositoryCatalogDataCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetRepositoryCatalogDataResponse(data, context);
+    contents = de_GetRepositoryCatalogDataResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetRepositoryCatalogDataCommandError = async (output, context) => {
+const de_GetRepositoryCatalogDataCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -762,19 +762,19 @@ const deserializeAws_json1_1GetRepositoryCatalogDataCommandError = async (output
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryCatalogDataNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryCatalogDataNotFoundException":
-            throw await deserializeAws_json1_1RepositoryCatalogDataNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryCatalogDataNotFoundExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -785,20 +785,20 @@ const deserializeAws_json1_1GetRepositoryCatalogDataCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1GetRepositoryPolicyCommand = async (output, context) => {
+export const de_GetRepositoryPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1GetRepositoryPolicyCommandError(output, context);
+        return de_GetRepositoryPolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1GetRepositoryPolicyResponse(data, context);
+    contents = de_GetRepositoryPolicyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1GetRepositoryPolicyCommandError = async (output, context) => {
+const de_GetRepositoryPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -807,19 +807,19 @@ const deserializeAws_json1_1GetRepositoryPolicyCommandError = async (output, con
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "RepositoryPolicyNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryPolicyNotFoundException":
-            throw await deserializeAws_json1_1RepositoryPolicyNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryPolicyNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -830,20 +830,20 @@ const deserializeAws_json1_1GetRepositoryPolicyCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1InitiateLayerUploadCommand = async (output, context) => {
+export const de_InitiateLayerUploadCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1InitiateLayerUploadCommandError(output, context);
+        return de_InitiateLayerUploadCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1InitiateLayerUploadResponse(data, context);
+    contents = de_InitiateLayerUploadResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1InitiateLayerUploadCommandError = async (output, context) => {
+const de_InitiateLayerUploadCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -852,19 +852,19 @@ const deserializeAws_json1_1InitiateLayerUploadCommandError = async (output, con
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RegistryNotFoundException":
         case "com.amazonaws.ecrpublic#RegistryNotFoundException":
-            throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RegistryNotFoundExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -875,20 +875,20 @@ const deserializeAws_json1_1InitiateLayerUploadCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
+export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1ListTagsForResourceCommandError(output, context);
+        return de_ListTagsForResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1ListTagsForResourceResponse(data, context);
+    contents = de_ListTagsForResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, context) => {
+const de_ListTagsForResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -897,16 +897,16 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -917,20 +917,20 @@ const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1PutImageCommand = async (output, context) => {
+export const de_PutImageCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutImageCommandError(output, context);
+        return de_PutImageCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutImageResponse(data, context);
+    contents = de_PutImageResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutImageCommandError = async (output, context) => {
+const de_PutImageCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -939,37 +939,37 @@ const deserializeAws_json1_1PutImageCommandError = async (output, context) => {
     switch (errorCode) {
         case "ImageAlreadyExistsException":
         case "com.amazonaws.ecrpublic#ImageAlreadyExistsException":
-            throw await deserializeAws_json1_1ImageAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ImageAlreadyExistsExceptionRes(parsedOutput, context);
         case "ImageDigestDoesNotMatchException":
         case "com.amazonaws.ecrpublic#ImageDigestDoesNotMatchException":
-            throw await deserializeAws_json1_1ImageDigestDoesNotMatchExceptionResponse(parsedOutput, context);
+            throw await de_ImageDigestDoesNotMatchExceptionRes(parsedOutput, context);
         case "ImageTagAlreadyExistsException":
         case "com.amazonaws.ecrpublic#ImageTagAlreadyExistsException":
-            throw await deserializeAws_json1_1ImageTagAlreadyExistsExceptionResponse(parsedOutput, context);
+            throw await de_ImageTagAlreadyExistsExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LayersNotFoundException":
         case "com.amazonaws.ecrpublic#LayersNotFoundException":
-            throw await deserializeAws_json1_1LayersNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_LayersNotFoundExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.ecrpublic#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "ReferencedImagesNotFoundException":
         case "com.amazonaws.ecrpublic#ReferencedImagesNotFoundException":
-            throw await deserializeAws_json1_1ReferencedImagesNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_ReferencedImagesNotFoundExceptionRes(parsedOutput, context);
         case "RegistryNotFoundException":
         case "com.amazonaws.ecrpublic#RegistryNotFoundException":
-            throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RegistryNotFoundExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -980,20 +980,20 @@ const deserializeAws_json1_1PutImageCommandError = async (output, context) => {
             });
     }
 };
-export const deserializeAws_json1_1PutRegistryCatalogDataCommand = async (output, context) => {
+export const de_PutRegistryCatalogDataCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutRegistryCatalogDataCommandError(output, context);
+        return de_PutRegistryCatalogDataCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutRegistryCatalogDataResponse(data, context);
+    contents = de_PutRegistryCatalogDataResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutRegistryCatalogDataCommandError = async (output, context) => {
+const de_PutRegistryCatalogDataCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1002,13 +1002,13 @@ const deserializeAws_json1_1PutRegistryCatalogDataCommandError = async (output,
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1019,20 +1019,20 @@ const deserializeAws_json1_1PutRegistryCatalogDataCommandError = async (output,
             });
     }
 };
-export const deserializeAws_json1_1PutRepositoryCatalogDataCommand = async (output, context) => {
+export const de_PutRepositoryCatalogDataCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1PutRepositoryCatalogDataCommandError(output, context);
+        return de_PutRepositoryCatalogDataCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1PutRepositoryCatalogDataResponse(data, context);
+    contents = de_PutRepositoryCatalogDataResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1PutRepositoryCatalogDataCommandError = async (output, context) => {
+const de_PutRepositoryCatalogDataCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1041,16 +1041,16 @@ const deserializeAws_json1_1PutRepositoryCatalogDataCommandError = async (output
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1061,20 +1061,20 @@ const deserializeAws_json1_1PutRepositoryCatalogDataCommandError = async (output
             });
     }
 };
-export const deserializeAws_json1_1SetRepositoryPolicyCommand = async (output, context) => {
+export const de_SetRepositoryPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1SetRepositoryPolicyCommandError(output, context);
+        return de_SetRepositoryPolicyCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1SetRepositoryPolicyResponse(data, context);
+    contents = de_SetRepositoryPolicyResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1SetRepositoryPolicyCommandError = async (output, context) => {
+const de_SetRepositoryPolicyCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1083,16 +1083,16 @@ const deserializeAws_json1_1SetRepositoryPolicyCommandError = async (output, con
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1103,20 +1103,20 @@ const deserializeAws_json1_1SetRepositoryPolicyCommandError = async (output, con
             });
     }
 };
-export const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
+export const de_TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1TagResourceCommandError(output, context);
+        return de_TagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1TagResourceResponse(data, context);
+    contents = de_TagResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1TagResourceCommandError = async (output, context) => {
+const de_TagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1125,22 +1125,22 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidTagParameterException":
         case "com.amazonaws.ecrpublic#InvalidTagParameterException":
-            throw await deserializeAws_json1_1InvalidTagParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTagParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.ecrpublic#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1151,20 +1151,20 @@ const deserializeAws_json1_1TagResourceCommandError = async (output, context) =>
             });
     }
 };
-export const deserializeAws_json1_1UntagResourceCommand = async (output, context) => {
+export const de_UntagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UntagResourceCommandError(output, context);
+        return de_UntagResourceCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UntagResourceResponse(data, context);
+    contents = de_UntagResourceResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UntagResourceCommandError = async (output, context) => {
+const de_UntagResourceCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1173,22 +1173,22 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
     switch (errorCode) {
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "InvalidTagParameterException":
         case "com.amazonaws.ecrpublic#InvalidTagParameterException":
-            throw await deserializeAws_json1_1InvalidTagParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidTagParameterExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "TooManyTagsException":
         case "com.amazonaws.ecrpublic#TooManyTagsException":
-            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+            throw await de_TooManyTagsExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1199,20 +1199,20 @@ const deserializeAws_json1_1UntagResourceCommandError = async (output, context)
             });
     }
 };
-export const deserializeAws_json1_1UploadLayerPartCommand = async (output, context) => {
+export const de_UploadLayerPartCommand = async (output, context) => {
     if (output.statusCode >= 300) {
-        return deserializeAws_json1_1UploadLayerPartCommandError(output, context);
+        return de_UploadLayerPartCommandError(output, context);
     }
     const data = await parseBody(output.body, context);
     let contents = {};
-    contents = deserializeAws_json1_1UploadLayerPartResponse(data, context);
+    contents = de_UploadLayerPartResponse(data, context);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
     };
     return Promise.resolve(response);
 };
-const deserializeAws_json1_1UploadLayerPartCommandError = async (output, context) => {
+const de_UploadLayerPartCommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
         body: await parseErrorBody(output.body, context),
@@ -1221,28 +1221,28 @@ const deserializeAws_json1_1UploadLayerPartCommandError = async (output, context
     switch (errorCode) {
         case "InvalidLayerPartException":
         case "com.amazonaws.ecrpublic#InvalidLayerPartException":
-            throw await deserializeAws_json1_1InvalidLayerPartExceptionResponse(parsedOutput, context);
+            throw await de_InvalidLayerPartExceptionRes(parsedOutput, context);
         case "InvalidParameterException":
         case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await deserializeAws_json1_1InvalidParameterExceptionResponse(parsedOutput, context);
+            throw await de_InvalidParameterExceptionRes(parsedOutput, context);
         case "LimitExceededException":
         case "com.amazonaws.ecrpublic#LimitExceededException":
-            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+            throw await de_LimitExceededExceptionRes(parsedOutput, context);
         case "RegistryNotFoundException":
         case "com.amazonaws.ecrpublic#RegistryNotFoundException":
-            throw await deserializeAws_json1_1RegistryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RegistryNotFoundExceptionRes(parsedOutput, context);
         case "RepositoryNotFoundException":
         case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await deserializeAws_json1_1RepositoryNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
         case "ServerException":
         case "com.amazonaws.ecrpublic#ServerException":
-            throw await deserializeAws_json1_1ServerExceptionResponse(parsedOutput, context);
+            throw await de_ServerExceptionRes(parsedOutput, context);
         case "UnsupportedCommandException":
         case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await deserializeAws_json1_1UnsupportedCommandExceptionResponse(parsedOutput, context);
+            throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
         case "UploadNotFoundException":
         case "com.amazonaws.ecrpublic#UploadNotFoundException":
-            throw await deserializeAws_json1_1UploadNotFoundExceptionResponse(parsedOutput, context);
+            throw await de_UploadNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             throwDefaultError({
@@ -1253,294 +1253,290 @@ const deserializeAws_json1_1UploadLayerPartCommandError = async (output, context
             });
     }
 };
-const deserializeAws_json1_1EmptyUploadExceptionResponse = async (parsedOutput, context) => {
+const de_EmptyUploadExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1EmptyUploadException(body, context);
+    const deserialized = de_EmptyUploadException(body, context);
     const exception = new EmptyUploadException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ImageAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
+const de_ImageAlreadyExistsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ImageAlreadyExistsException(body, context);
+    const deserialized = de_ImageAlreadyExistsException(body, context);
     const exception = new ImageAlreadyExistsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ImageDigestDoesNotMatchExceptionResponse = async (parsedOutput, context) => {
+const de_ImageDigestDoesNotMatchExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ImageDigestDoesNotMatchException(body, context);
+    const deserialized = de_ImageDigestDoesNotMatchException(body, context);
     const exception = new ImageDigestDoesNotMatchException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ImageNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ImageNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ImageNotFoundException(body, context);
+    const deserialized = de_ImageNotFoundException(body, context);
     const exception = new ImageNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ImageTagAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
+const de_ImageTagAlreadyExistsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ImageTagAlreadyExistsException(body, context);
+    const deserialized = de_ImageTagAlreadyExistsException(body, context);
     const exception = new ImageTagAlreadyExistsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidLayerExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidLayerExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidLayerException(body, context);
+    const deserialized = de_InvalidLayerException(body, context);
     const exception = new InvalidLayerException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1InvalidLayerPartExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidLayerPartExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidLayerPartException(body, context);
+    const deserialized = de_InvalidLayerPartException(body, context);
     const exception = new InvalidLayerPartException({
         $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_1InvalidTagParameterExceptionResponse = async (parsedOutput, context) => {
+const de_InvalidTagParameterExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1InvalidTagParameterException(body, context);
+    const deserialized = de_InvalidTagParameterException(body, context);
     const exception = new InvalidTagParameterException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1LayerAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
+const de_LayerAlreadyExistsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1LayerAlreadyExistsException(body, context);
+    const deserialized = de_LayerAlreadyExistsException(body, context);
     const exception = new LayerAlreadyExistsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1LayerPartTooSmallExceptionResponse = async (parsedOutput, context) => {
+const de_LayerPartTooSmallExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1LayerPartTooSmallException(body, context);
+    const deserialized = de_LayerPartTooSmallException(body, context);
     const exception = new LayerPartTooSmallException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1LayersNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_LayersNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1LayersNotFoundException(body, context);
+    const deserialized = de_LayersNotFoundException(body, context);
     const exception = new LayersNotFoundException({
         $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_1ReferencedImagesNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_ReferencedImagesNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ReferencedImagesNotFoundException(body, context);
+    const deserialized = de_ReferencedImagesNotFoundException(body, context);
     const exception = new ReferencedImagesNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1RegistryNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_RegistryNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1RegistryNotFoundException(body, context);
+    const deserialized = de_RegistryNotFoundException(body, context);
     const exception = new RegistryNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1RepositoryAlreadyExistsExceptionResponse = async (parsedOutput, context) => {
+const de_RepositoryAlreadyExistsExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1RepositoryAlreadyExistsException(body, context);
+    const deserialized = de_RepositoryAlreadyExistsException(body, context);
     const exception = new RepositoryAlreadyExistsException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1RepositoryCatalogDataNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_RepositoryCatalogDataNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1RepositoryCatalogDataNotFoundException(body, context);
+    const deserialized = de_RepositoryCatalogDataNotFoundException(body, context);
     const exception = new RepositoryCatalogDataNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1RepositoryNotEmptyExceptionResponse = async (parsedOutput, context) => {
+const de_RepositoryNotEmptyExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1RepositoryNotEmptyException(body, context);
+    const deserialized = de_RepositoryNotEmptyException(body, context);
     const exception = new RepositoryNotEmptyException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1RepositoryNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_RepositoryNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1RepositoryNotFoundException(body, context);
+    const deserialized = de_RepositoryNotFoundException(body, context);
     const exception = new RepositoryNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1RepositoryPolicyNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_RepositoryPolicyNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1RepositoryPolicyNotFoundException(body, context);
+    const deserialized = de_RepositoryPolicyNotFoundException(body, context);
     const exception = new RepositoryPolicyNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1ServerExceptionResponse = async (parsedOutput, context) => {
+const de_ServerExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1ServerException(body, context);
+    const deserialized = de_ServerException(body, context);
     const exception = new ServerException({
         $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_1UnsupportedCommandExceptionResponse = async (parsedOutput, context) => {
+const de_UnsupportedCommandExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1UnsupportedCommandException(body, context);
+    const deserialized = de_UnsupportedCommandException(body, context);
     const exception = new UnsupportedCommandException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const deserializeAws_json1_1UploadNotFoundExceptionResponse = async (parsedOutput, context) => {
+const de_UploadNotFoundExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_1UploadNotFoundException(body, context);
+    const deserialized = de_UploadNotFoundException(body, context);
     const exception = new UploadNotFoundException({
         $metadata: deserializeMetadata(parsedOutput),
         ...deserialized,
     });
     return __decorateServiceException(exception, body);
 };
-const serializeAws_json1_1ArchitectureList = (input, context) => {
+const se_ArchitectureList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1BatchCheckLayerAvailabilityRequest = (input, context) => {
+const se_BatchCheckLayerAvailabilityRequest = (input, context) => {
     return {
         ...(input.layerDigests != null && {
-            layerDigests: serializeAws_json1_1BatchedOperationLayerDigestList(input.layerDigests, context),
+            layerDigests: se_BatchedOperationLayerDigestList(input.layerDigests, context),
         }),
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1BatchDeleteImageRequest = (input, context) => {
+const se_BatchDeleteImageRequest = (input, context) => {
     return {
-        ...(input.imageIds != null && { imageIds: serializeAws_json1_1ImageIdentifierList(input.imageIds, context) }),
+        ...(input.imageIds != null && { imageIds: se_ImageIdentifierList(input.imageIds, context) }),
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1BatchedOperationLayerDigestList = (input, context) => {
+const se_BatchedOperationLayerDigestList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1CompleteLayerUploadRequest = (input, context) => {
+const se_CompleteLayerUploadRequest = (input, context) => {
     return {
-        ...(input.layerDigests != null && {
-            layerDigests: serializeAws_json1_1LayerDigestList(input.layerDigests, context),
-        }),
+        ...(input.layerDigests != null && { layerDigests: se_LayerDigestList(input.layerDigests, context) }),
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
         ...(input.uploadId != null && { uploadId: input.uploadId }),
     };
 };
-const serializeAws_json1_1CreateRepositoryRequest = (input, context) => {
+const se_CreateRepositoryRequest = (input, context) => {
     return {
-        ...(input.catalogData != null && {
-            catalogData: serializeAws_json1_1RepositoryCatalogDataInput(input.catalogData, context),
-        }),
+        ...(input.catalogData != null && { catalogData: se_RepositoryCatalogDataInput(input.catalogData, context) }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
-        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagList(input.tags, context) }),
     };
 };
-const serializeAws_json1_1DeleteRepositoryPolicyRequest = (input, context) => {
+const se_DeleteRepositoryPolicyRequest = (input, context) => {
     return {
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1DeleteRepositoryRequest = (input, context) => {
+const se_DeleteRepositoryRequest = (input, context) => {
     return {
         ...(input.force != null && { force: input.force }),
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1DescribeImagesRequest = (input, context) => {
+const se_DescribeImagesRequest = (input, context) => {
     return {
-        ...(input.imageIds != null && { imageIds: serializeAws_json1_1ImageIdentifierList(input.imageIds, context) }),
+        ...(input.imageIds != null && { imageIds: se_ImageIdentifierList(input.imageIds, context) }),
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1DescribeImageTagsRequest = (input, context) => {
+const se_DescribeImageTagsRequest = (input, context) => {
     return {
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
@@ -1548,79 +1544,77 @@ const serializeAws_json1_1DescribeImageTagsRequest = (input, context) => {
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1DescribeRegistriesRequest = (input, context) => {
+const se_DescribeRegistriesRequest = (input, context) => {
     return {
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
     };
 };
-const serializeAws_json1_1DescribeRepositoriesRequest = (input, context) => {
+const se_DescribeRepositoriesRequest = (input, context) => {
     return {
         ...(input.maxResults != null && { maxResults: input.maxResults }),
         ...(input.nextToken != null && { nextToken: input.nextToken }),
         ...(input.registryId != null && { registryId: input.registryId }),
-        ...(input.repositoryNames != null && {
-            repositoryNames: serializeAws_json1_1RepositoryNameList(input.repositoryNames, context),
-        }),
+        ...(input.repositoryNames != null && { repositoryNames: se_RepositoryNameList(input.repositoryNames, context) }),
     };
 };
-const serializeAws_json1_1GetAuthorizationTokenRequest = (input, context) => {
+const se_GetAuthorizationTokenRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1GetRegistryCatalogDataRequest = (input, context) => {
+const se_GetRegistryCatalogDataRequest = (input, context) => {
     return {};
 };
-const serializeAws_json1_1GetRepositoryCatalogDataRequest = (input, context) => {
+const se_GetRepositoryCatalogDataRequest = (input, context) => {
     return {
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1GetRepositoryPolicyRequest = (input, context) => {
+const se_GetRepositoryPolicyRequest = (input, context) => {
     return {
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1ImageIdentifier = (input, context) => {
+const se_ImageIdentifier = (input, context) => {
     return {
         ...(input.imageDigest != null && { imageDigest: input.imageDigest }),
         ...(input.imageTag != null && { imageTag: input.imageTag }),
     };
 };
-const serializeAws_json1_1ImageIdentifierList = (input, context) => {
+const se_ImageIdentifierList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        return serializeAws_json1_1ImageIdentifier(entry, context);
+        return se_ImageIdentifier(entry, context);
     });
 };
-const serializeAws_json1_1InitiateLayerUploadRequest = (input, context) => {
+const se_InitiateLayerUploadRequest = (input, context) => {
     return {
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1LayerDigestList = (input, context) => {
+const se_LayerDigestList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1ListTagsForResourceRequest = (input, context) => {
+const se_ListTagsForResourceRequest = (input, context) => {
     return {
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
     };
 };
-const serializeAws_json1_1OperatingSystemList = (input, context) => {
+const se_OperatingSystemList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1PutImageRequest = (input, context) => {
+const se_PutImageRequest = (input, context) => {
     return {
         ...(input.imageDigest != null && { imageDigest: input.imageDigest }),
         ...(input.imageManifest != null && { imageManifest: input.imageManifest }),
@@ -1630,42 +1624,38 @@ const serializeAws_json1_1PutImageRequest = (input, context) => {
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1PutRegistryCatalogDataRequest = (input, context) => {
+const se_PutRegistryCatalogDataRequest = (input, context) => {
     return {
         ...(input.displayName != null && { displayName: input.displayName }),
     };
 };
-const serializeAws_json1_1PutRepositoryCatalogDataRequest = (input, context) => {
+const se_PutRepositoryCatalogDataRequest = (input, context) => {
     return {
-        ...(input.catalogData != null && {
-            catalogData: serializeAws_json1_1RepositoryCatalogDataInput(input.catalogData, context),
-        }),
+        ...(input.catalogData != null && { catalogData: se_RepositoryCatalogDataInput(input.catalogData, context) }),
         ...(input.registryId != null && { registryId: input.registryId }),
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-const serializeAws_json1_1RepositoryCatalogDataInput = (input, context) => {
+const se_RepositoryCatalogDataInput = (input, context) => {
     return {
         ...(input.aboutText != null && { aboutText: input.aboutText }),
-        ...(input.architectures != null && {
-            architectures: serializeAws_json1_1ArchitectureList(input.architectures, context),
-        }),
+        ...(input.architectures != null && { architectures: se_ArchitectureList(input.architectures, context) }),
         ...(input.description != null && { description: input.description }),
         ...(input.logoImageBlob != null && { logoImageBlob: context.base64Encoder(input.logoImageBlob) }),
         ...(input.operatingSystems != null && {
-            operatingSystems: serializeAws_json1_1OperatingSystemList(input.operatingSystems, context),
+            operatingSystems: se_OperatingSystemList(input.operatingSystems, context),
         }),
         ...(input.usageText != null && { usageText: input.usageText }),
     };
 };
-const serializeAws_json1_1RepositoryNameList = (input, context) => {
+const se_RepositoryNameList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-const serializeAws_json1_1SetRepositoryPolicyRequest = (input, context) => {
+const se_SetRepositoryPolicyRequest = (input, context) => {
     return {
         ...(input.force != null && { force: input.force }),
         ...(input.policyText != null && { policyText: input.policyText }),
@@ -1673,39 +1663,39 @@ const serializeAws_json1_1SetRepositoryPolicyRequest = (input, context) => {
         ...(input.repositoryName != null && { repositoryName: input.repositoryName }),
     };
 };
-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_1TagKeyList = (input, context) => {
+const se_TagKeyList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
         return entry;
     });
 };
-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_1TagResourceRequest = (input, context) => {
+const se_TagResourceRequest = (input, context) => {
     return {
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
-        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.tags != null && { tags: se_TagList(input.tags, context) }),
     };
 };
-const serializeAws_json1_1UntagResourceRequest = (input, context) => {
+const se_UntagResourceRequest = (input, context) => {
     return {
         ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
-        ...(input.tagKeys != null && { tagKeys: serializeAws_json1_1TagKeyList(input.tagKeys, context) }),
+        ...(input.tagKeys != null && { tagKeys: se_TagKeyList(input.tagKeys, context) }),
     };
 };
-const serializeAws_json1_1UploadLayerPartRequest = (input, context) => {
+const se_UploadLayerPartRequest = (input, context) => {
     return {
         ...(input.layerPartBlob != null && { layerPartBlob: context.base64Encoder(input.layerPartBlob) }),
         ...(input.partFirstByte != null && { partFirstByte: input.partFirstByte }),
@@ -1715,7 +1705,7 @@ const serializeAws_json1_1UploadLayerPartRequest = (input, context) => {
         ...(input.uploadId != null && { uploadId: input.uploadId }),
     };
 };
-const deserializeAws_json1_1ArchitectureList = (output, context) => {
+const de_ArchitectureList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1726,25 +1716,25 @@ const deserializeAws_json1_1ArchitectureList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1AuthorizationData = (output, context) => {
+const de_AuthorizationData = (output, context) => {
     return {
         authorizationToken: __expectString(output.authorizationToken),
         expiresAt: output.expiresAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.expiresAt))) : undefined,
     };
 };
-const deserializeAws_json1_1BatchCheckLayerAvailabilityResponse = (output, context) => {
+const de_BatchCheckLayerAvailabilityResponse = (output, context) => {
     return {
-        failures: output.failures != null ? deserializeAws_json1_1LayerFailureList(output.failures, context) : undefined,
-        layers: output.layers != null ? deserializeAws_json1_1LayerList(output.layers, context) : undefined,
+        failures: output.failures != null ? de_LayerFailureList(output.failures, context) : undefined,
+        layers: output.layers != null ? de_LayerList(output.layers, context) : undefined,
     };
 };
-const deserializeAws_json1_1BatchDeleteImageResponse = (output, context) => {
+const de_BatchDeleteImageResponse = (output, context) => {
     return {
-        failures: output.failures != null ? deserializeAws_json1_1ImageFailureList(output.failures, context) : undefined,
-        imageIds: output.imageIds != null ? deserializeAws_json1_1ImageIdentifierList(output.imageIds, context) : undefined,
+        failures: output.failures != null ? de_ImageFailureList(output.failures, context) : undefined,
+        imageIds: output.imageIds != null ? de_ImageIdentifierList(output.imageIds, context) : undefined,
     };
 };
-const deserializeAws_json1_1CompleteLayerUploadResponse = (output, context) => {
+const de_CompleteLayerUploadResponse = (output, context) => {
     return {
         layerDigest: __expectString(output.layerDigest),
         registryId: __expectString(output.registryId),
@@ -1752,96 +1742,90 @@ const deserializeAws_json1_1CompleteLayerUploadResponse = (output, context) => {
         uploadId: __expectString(output.uploadId),
     };
 };
-const deserializeAws_json1_1CreateRepositoryResponse = (output, context) => {
+const de_CreateRepositoryResponse = (output, context) => {
     return {
-        catalogData: output.catalogData != null ? deserializeAws_json1_1RepositoryCatalogData(output.catalogData, context) : undefined,
-        repository: output.repository != null ? deserializeAws_json1_1Repository(output.repository, context) : undefined,
+        catalogData: output.catalogData != null ? de_RepositoryCatalogData(output.catalogData, context) : undefined,
+        repository: output.repository != null ? de_Repository(output.repository, context) : undefined,
     };
 };
-const deserializeAws_json1_1DeleteRepositoryPolicyResponse = (output, context) => {
+const de_DeleteRepositoryPolicyResponse = (output, context) => {
     return {
         policyText: __expectString(output.policyText),
         registryId: __expectString(output.registryId),
         repositoryName: __expectString(output.repositoryName),
     };
 };
-const deserializeAws_json1_1DeleteRepositoryResponse = (output, context) => {
+const de_DeleteRepositoryResponse = (output, context) => {
     return {
-        repository: output.repository != null ? deserializeAws_json1_1Repository(output.repository, context) : undefined,
+        repository: output.repository != null ? de_Repository(output.repository, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeImagesResponse = (output, context) => {
+const de_DescribeImagesResponse = (output, context) => {
     return {
-        imageDetails: output.imageDetails != null ? deserializeAws_json1_1ImageDetailList(output.imageDetails, context) : undefined,
+        imageDetails: output.imageDetails != null ? de_ImageDetailList(output.imageDetails, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_1DescribeImageTagsResponse = (output, context) => {
+const de_DescribeImageTagsResponse = (output, context) => {
     return {
-        imageTagDetails: output.imageTagDetails != null
-            ? deserializeAws_json1_1ImageTagDetailList(output.imageTagDetails, context)
-            : undefined,
+        imageTagDetails: output.imageTagDetails != null ? de_ImageTagDetailList(output.imageTagDetails, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_1DescribeRegistriesResponse = (output, context) => {
+const de_DescribeRegistriesResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        registries: output.registries != null ? deserializeAws_json1_1RegistryList(output.registries, context) : undefined,
+        registries: output.registries != null ? de_RegistryList(output.registries, context) : undefined,
     };
 };
-const deserializeAws_json1_1DescribeRepositoriesResponse = (output, context) => {
+const de_DescribeRepositoriesResponse = (output, context) => {
     return {
         nextToken: __expectString(output.nextToken),
-        repositories: output.repositories != null ? deserializeAws_json1_1RepositoryList(output.repositories, context) : undefined,
+        repositories: output.repositories != null ? de_RepositoryList(output.repositories, context) : undefined,
     };
 };
-const deserializeAws_json1_1EmptyUploadException = (output, context) => {
+const de_EmptyUploadException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1GetAuthorizationTokenResponse = (output, context) => {
+const de_GetAuthorizationTokenResponse = (output, context) => {
     return {
-        authorizationData: output.authorizationData != null
-            ? deserializeAws_json1_1AuthorizationData(output.authorizationData, context)
-            : undefined,
+        authorizationData: output.authorizationData != null ? de_AuthorizationData(output.authorizationData, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetRegistryCatalogDataResponse = (output, context) => {
+const de_GetRegistryCatalogDataResponse = (output, context) => {
     return {
-        registryCatalogData: output.registryCatalogData != null
-            ? deserializeAws_json1_1RegistryCatalogData(output.registryCatalogData, context)
-            : undefined,
+        registryCatalogData: output.registryCatalogData != null ? de_RegistryCatalogData(output.registryCatalogData, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetRepositoryCatalogDataResponse = (output, context) => {
+const de_GetRepositoryCatalogDataResponse = (output, context) => {
     return {
-        catalogData: output.catalogData != null ? deserializeAws_json1_1RepositoryCatalogData(output.catalogData, context) : undefined,
+        catalogData: output.catalogData != null ? de_RepositoryCatalogData(output.catalogData, context) : undefined,
     };
 };
-const deserializeAws_json1_1GetRepositoryPolicyResponse = (output, context) => {
+const de_GetRepositoryPolicyResponse = (output, context) => {
     return {
         policyText: __expectString(output.policyText),
         registryId: __expectString(output.registryId),
         repositoryName: __expectString(output.repositoryName),
     };
 };
-const deserializeAws_json1_1Image = (output, context) => {
+const de_Image = (output, context) => {
     return {
-        imageId: output.imageId != null ? deserializeAws_json1_1ImageIdentifier(output.imageId, context) : undefined,
+        imageId: output.imageId != null ? de_ImageIdentifier(output.imageId, context) : undefined,
         imageManifest: __expectString(output.imageManifest),
         imageManifestMediaType: __expectString(output.imageManifestMediaType),
         registryId: __expectString(output.registryId),
         repositoryName: __expectString(output.repositoryName),
     };
 };
-const deserializeAws_json1_1ImageAlreadyExistsException = (output, context) => {
+const de_ImageAlreadyExistsException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ImageDetail = (output, context) => {
+const de_ImageDetail = (output, context) => {
     return {
         artifactMediaType: __expectString(output.artifactMediaType),
         imageDigest: __expectString(output.imageDigest),
@@ -1850,91 +1834,91 @@ const deserializeAws_json1_1ImageDetail = (output, context) => {
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.imagePushedAt)))
             : undefined,
         imageSizeInBytes: __expectLong(output.imageSizeInBytes),
-        imageTags: output.imageTags != null ? deserializeAws_json1_1ImageTagList(output.imageTags, context) : undefined,
+        imageTags: output.imageTags != null ? de_ImageTagList(output.imageTags, context) : undefined,
         registryId: __expectString(output.registryId),
         repositoryName: __expectString(output.repositoryName),
     };
 };
-const deserializeAws_json1_1ImageDetailList = (output, context) => {
+const de_ImageDetailList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ImageDetail(entry, context);
+        return de_ImageDetail(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ImageDigestDoesNotMatchException = (output, context) => {
+const de_ImageDigestDoesNotMatchException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ImageFailure = (output, context) => {
+const de_ImageFailure = (output, context) => {
     return {
         failureCode: __expectString(output.failureCode),
         failureReason: __expectString(output.failureReason),
-        imageId: output.imageId != null ? deserializeAws_json1_1ImageIdentifier(output.imageId, context) : undefined,
+        imageId: output.imageId != null ? de_ImageIdentifier(output.imageId, context) : undefined,
     };
 };
-const deserializeAws_json1_1ImageFailureList = (output, context) => {
+const de_ImageFailureList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ImageFailure(entry, context);
+        return de_ImageFailure(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ImageIdentifier = (output, context) => {
+const de_ImageIdentifier = (output, context) => {
     return {
         imageDigest: __expectString(output.imageDigest),
         imageTag: __expectString(output.imageTag),
     };
 };
-const deserializeAws_json1_1ImageIdentifierList = (output, context) => {
+const de_ImageIdentifierList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ImageIdentifier(entry, context);
+        return de_ImageIdentifier(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ImageNotFoundException = (output, context) => {
+const de_ImageNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ImageTagAlreadyExistsException = (output, context) => {
+const de_ImageTagAlreadyExistsException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ImageTagDetail = (output, context) => {
+const de_ImageTagDetail = (output, context) => {
     return {
         createdAt: output.createdAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createdAt))) : undefined,
-        imageDetail: output.imageDetail != null ? deserializeAws_json1_1ReferencedImageDetail(output.imageDetail, context) : undefined,
+        imageDetail: output.imageDetail != null ? de_ReferencedImageDetail(output.imageDetail, context) : undefined,
         imageTag: __expectString(output.imageTag),
     };
 };
-const deserializeAws_json1_1ImageTagDetailList = (output, context) => {
+const de_ImageTagDetailList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1ImageTagDetail(entry, context);
+        return de_ImageTagDetail(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1ImageTagList = (output, context) => {
+const de_ImageTagList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -1945,18 +1929,18 @@ const deserializeAws_json1_1ImageTagList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1InitiateLayerUploadResponse = (output, context) => {
+const de_InitiateLayerUploadResponse = (output, context) => {
     return {
         partSize: __expectLong(output.partSize),
         uploadId: __expectString(output.uploadId),
     };
 };
-const deserializeAws_json1_1InvalidLayerException = (output, context) => {
+const de_InvalidLayerException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidLayerPartException = (output, context) => {
+const de_InvalidLayerPartException = (output, context) => {
     return {
         lastValidByteReceived: __expectLong(output.lastValidByteReceived),
         message: __expectString(output.message),
@@ -1965,17 +1949,17 @@ const deserializeAws_json1_1InvalidLayerPartException = (output, context) => {
         uploadId: __expectString(output.uploadId),
     };
 };
-const deserializeAws_json1_1InvalidParameterException = (output, context) => {
+const de_InvalidParameterException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1InvalidTagParameterException = (output, context) => {
+const de_InvalidTagParameterException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1Layer = (output, context) => {
+const de_Layer = (output, context) => {
     return {
         layerAvailability: __expectString(output.layerAvailability),
         layerDigest: __expectString(output.layerDigest),
@@ -1983,61 +1967,61 @@ const deserializeAws_json1_1Layer = (output, context) => {
         mediaType: __expectString(output.mediaType),
     };
 };
-const deserializeAws_json1_1LayerAlreadyExistsException = (output, context) => {
+const de_LayerAlreadyExistsException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1LayerFailure = (output, context) => {
+const de_LayerFailure = (output, context) => {
     return {
         failureCode: __expectString(output.failureCode),
         failureReason: __expectString(output.failureReason),
         layerDigest: __expectString(output.layerDigest),
     };
 };
-const deserializeAws_json1_1LayerFailureList = (output, context) => {
+const de_LayerFailureList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1LayerFailure(entry, context);
+        return de_LayerFailure(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1LayerList = (output, context) => {
+const de_LayerList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Layer(entry, context);
+        return de_Layer(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1LayerPartTooSmallException = (output, context) => {
+const de_LayerPartTooSmallException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1LayersNotFoundException = (output, context) => {
+const de_LayersNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1LimitExceededException = (output, context) => {
+const de_LimitExceededException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ListTagsForResourceResponse = (output, context) => {
+const de_ListTagsForResourceResponse = (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_1OperatingSystemList = (output, context) => {
+const de_OperatingSystemList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
@@ -2048,24 +2032,22 @@ const deserializeAws_json1_1OperatingSystemList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_1PutImageResponse = (output, context) => {
+const de_PutImageResponse = (output, context) => {
     return {
-        image: output.image != null ? deserializeAws_json1_1Image(output.image, context) : undefined,
+        image: output.image != null ? de_Image(output.image, context) : undefined,
     };
 };
-const deserializeAws_json1_1PutRegistryCatalogDataResponse = (output, context) => {
+const de_PutRegistryCatalogDataResponse = (output, context) => {
     return {
-        registryCatalogData: output.registryCatalogData != null
-            ? deserializeAws_json1_1RegistryCatalogData(output.registryCatalogData, context)
-            : undefined,
+        registryCatalogData: output.registryCatalogData != null ? de_RegistryCatalogData(output.registryCatalogData, context) : undefined,
     };
 };
-const deserializeAws_json1_1PutRepositoryCatalogDataResponse = (output, context) => {
+const de_PutRepositoryCatalogDataResponse = (output, context) => {
     return {
-        catalogData: output.catalogData != null ? deserializeAws_json1_1RepositoryCatalogData(output.catalogData, context) : undefined,
+        catalogData: output.catalogData != null ? de_RepositoryCatalogData(output.catalogData, context) : undefined,
     };
 };
-const deserializeAws_json1_1ReferencedImageDetail = (output, context) => {
+const de_ReferencedImageDetail = (output, context) => {
     return {
         artifactMediaType: __expectString(output.artifactMediaType),
         imageDigest: __expectString(output.imageDigest),
@@ -2076,21 +2058,21 @@ const deserializeAws_json1_1ReferencedImageDetail = (output, context) => {
         imageSizeInBytes: __expectLong(output.imageSizeInBytes),
     };
 };
-const deserializeAws_json1_1ReferencedImagesNotFoundException = (output, context) => {
+const de_ReferencedImagesNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1Registry = (output, context) => {
+const de_Registry = (output, context) => {
     return {
-        aliases: output.aliases != null ? deserializeAws_json1_1RegistryAliasList(output.aliases, context) : undefined,
+        aliases: output.aliases != null ? de_RegistryAliasList(output.aliases, context) : undefined,
         registryArn: __expectString(output.registryArn),
         registryId: __expectString(output.registryId),
         registryUri: __expectString(output.registryUri),
         verified: __expectBoolean(output.verified),
     };
 };
-const deserializeAws_json1_1RegistryAlias = (output, context) => {
+const de_RegistryAlias = (output, context) => {
     return {
         defaultRegistryAlias: __expectBoolean(output.defaultRegistryAlias),
         name: __expectString(output.name),
@@ -2098,39 +2080,39 @@ const deserializeAws_json1_1RegistryAlias = (output, context) => {
         status: __expectString(output.status),
     };
 };
-const deserializeAws_json1_1RegistryAliasList = (output, context) => {
+const de_RegistryAliasList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1RegistryAlias(entry, context);
+        return de_RegistryAlias(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1RegistryCatalogData = (output, context) => {
+const de_RegistryCatalogData = (output, context) => {
     return {
         displayName: __expectString(output.displayName),
     };
 };
-const deserializeAws_json1_1RegistryList = (output, context) => {
+const de_RegistryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Registry(entry, context);
+        return de_Registry(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1RegistryNotFoundException = (output, context) => {
+const de_RegistryNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1Repository = (output, context) => {
+const de_Repository = (output, context) => {
     return {
         createdAt: output.createdAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.createdAt))) : undefined,
         registryId: __expectString(output.registryId),
@@ -2139,101 +2121,99 @@ const deserializeAws_json1_1Repository = (output, context) => {
         repositoryUri: __expectString(output.repositoryUri),
     };
 };
-const deserializeAws_json1_1RepositoryAlreadyExistsException = (output, context) => {
+const de_RepositoryAlreadyExistsException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1RepositoryCatalogData = (output, context) => {
+const de_RepositoryCatalogData = (output, context) => {
     return {
         aboutText: __expectString(output.aboutText),
-        architectures: output.architectures != null ? deserializeAws_json1_1ArchitectureList(output.architectures, context) : undefined,
+        architectures: output.architectures != null ? de_ArchitectureList(output.architectures, context) : undefined,
         description: __expectString(output.description),
         logoUrl: __expectString(output.logoUrl),
         marketplaceCertified: __expectBoolean(output.marketplaceCertified),
-        operatingSystems: output.operatingSystems != null
-            ? deserializeAws_json1_1OperatingSystemList(output.operatingSystems, context)
-            : undefined,
+        operatingSystems: output.operatingSystems != null ? de_OperatingSystemList(output.operatingSystems, context) : undefined,
         usageText: __expectString(output.usageText),
     };
 };
-const deserializeAws_json1_1RepositoryCatalogDataNotFoundException = (output, context) => {
+const de_RepositoryCatalogDataNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1RepositoryList = (output, context) => {
+const de_RepositoryList = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
         .map((entry) => {
         if (entry === null) {
             return null;
         }
-        return deserializeAws_json1_1Repository(entry, context);
+        return de_Repository(entry, context);
     });
     return retVal;
 };
-const deserializeAws_json1_1RepositoryNotEmptyException = (output, context) => {
+const de_RepositoryNotEmptyException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1RepositoryNotFoundException = (output, context) => {
+const de_RepositoryNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1RepositoryPolicyNotFoundException = (output, context) => {
+const de_RepositoryPolicyNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1ServerException = (output, context) => {
+const de_ServerException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1SetRepositoryPolicyResponse = (output, context) => {
+const de_SetRepositoryPolicyResponse = (output, context) => {
     return {
         policyText: __expectString(output.policyText),
         registryId: __expectString(output.registryId),
         repositoryName: __expectString(output.repositoryName),
     };
 };
-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_1TagResourceResponse = (output, context) => {
+const de_TagResourceResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1TooManyTagsException = (output, context) => {
+const de_TooManyTagsException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1UnsupportedCommandException = (output, context) => {
+const de_UnsupportedCommandException = (output, context) => {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_1UntagResourceResponse = (output, context) => {
+const de_UntagResourceResponse = (output, context) => {
     return {};
 };
-const deserializeAws_json1_1UploadLayerPartResponse = (output, context) => {
+const de_UploadLayerPartResponse = (output, context) => {
     return {
         lastByteReceived: __expectLong(output.lastByteReceived),
         registryId: __expectString(output.registryId),
@@ -2241,7 +2221,7 @@ const deserializeAws_json1_1UploadLayerPartResponse = (output, context) => {
         uploadId: __expectString(output.uploadId),
     };
 };
-const deserializeAws_json1_1UploadNotFoundException = (output, context) => {
+const de_UploadNotFoundException = (output, context) => {
     return {
         message: __expectString(output.message),
     };