@aws-sdk/client-ecr-public 3.926.0 → 3.928.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class ECRPUBLICClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,12 +110,12 @@ class ECRPUBLICClient extends smithyClient.Client {
     }
 }
 
-class ECRPUBLICServiceException extends smithyClient.ServiceException {
+let ECRPUBLICServiceException$1 = class ECRPUBLICServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, ECRPUBLICServiceException.prototype);
     }
-}
+};
 
 const LayerFailureCode = {
     InvalidLayerDigest: "InvalidLayerDigest",
@@ -125,7 +125,7 @@ const LayerAvailability = {
     AVAILABLE: "AVAILABLE",
     UNAVAILABLE: "UNAVAILABLE",
 };
-class InvalidParameterException extends ECRPUBLICServiceException {
+let InvalidParameterException$1 = class InvalidParameterException extends ECRPUBLICServiceException$1 {
     name = "InvalidParameterException";
     $fault = "client";
     constructor(opts) {
@@ -136,8 +136,8 @@ class InvalidParameterException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, InvalidParameterException.prototype);
     }
-}
-class RegistryNotFoundException extends ECRPUBLICServiceException {
+};
+let RegistryNotFoundException$1 = class RegistryNotFoundException extends ECRPUBLICServiceException$1 {
     name = "RegistryNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -148,8 +148,8 @@ class RegistryNotFoundException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, RegistryNotFoundException.prototype);
     }
-}
-class RepositoryNotFoundException extends ECRPUBLICServiceException {
+};
+let RepositoryNotFoundException$1 = class RepositoryNotFoundException extends ECRPUBLICServiceException$1 {
     name = "RepositoryNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -160,8 +160,8 @@ class RepositoryNotFoundException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, RepositoryNotFoundException.prototype);
     }
-}
-class ServerException extends ECRPUBLICServiceException {
+};
+let ServerException$1 = class ServerException extends ECRPUBLICServiceException$1 {
     name = "ServerException";
     $fault = "server";
     constructor(opts) {
@@ -172,8 +172,8 @@ class ServerException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, ServerException.prototype);
     }
-}
-class UnsupportedCommandException extends ECRPUBLICServiceException {
+};
+let UnsupportedCommandException$1 = class UnsupportedCommandException extends ECRPUBLICServiceException$1 {
     name = "UnsupportedCommandException";
     $fault = "client";
     constructor(opts) {
@@ -184,7 +184,7 @@ class UnsupportedCommandException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, UnsupportedCommandException.prototype);
     }
-}
+};
 const ImageFailureCode = {
     ImageNotFound: "ImageNotFound",
     ImageReferencedByManifestList: "ImageReferencedByManifestList",
@@ -194,7 +194,7 @@ const ImageFailureCode = {
     KmsError: "KmsError",
     MissingDigestAndTag: "MissingDigestAndTag",
 };
-class EmptyUploadException extends ECRPUBLICServiceException {
+let EmptyUploadException$1 = class EmptyUploadException extends ECRPUBLICServiceException$1 {
     name = "EmptyUploadException";
     $fault = "client";
     constructor(opts) {
@@ -205,8 +205,8 @@ class EmptyUploadException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, EmptyUploadException.prototype);
     }
-}
-class InvalidLayerException extends ECRPUBLICServiceException {
+};
+let InvalidLayerException$1 = class InvalidLayerException extends ECRPUBLICServiceException$1 {
     name = "InvalidLayerException";
     $fault = "client";
     constructor(opts) {
@@ -217,8 +217,8 @@ class InvalidLayerException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, InvalidLayerException.prototype);
     }
-}
-class LayerAlreadyExistsException extends ECRPUBLICServiceException {
+};
+let LayerAlreadyExistsException$1 = class LayerAlreadyExistsException extends ECRPUBLICServiceException$1 {
     name = "LayerAlreadyExistsException";
     $fault = "client";
     constructor(opts) {
@@ -229,8 +229,8 @@ class LayerAlreadyExistsException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, LayerAlreadyExistsException.prototype);
     }
-}
-class LayerPartTooSmallException extends ECRPUBLICServiceException {
+};
+let LayerPartTooSmallException$1 = class LayerPartTooSmallException extends ECRPUBLICServiceException$1 {
     name = "LayerPartTooSmallException";
     $fault = "client";
     constructor(opts) {
@@ -241,8 +241,8 @@ class LayerPartTooSmallException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, LayerPartTooSmallException.prototype);
     }
-}
-class UploadNotFoundException extends ECRPUBLICServiceException {
+};
+let UploadNotFoundException$1 = class UploadNotFoundException extends ECRPUBLICServiceException$1 {
     name = "UploadNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -253,8 +253,8 @@ class UploadNotFoundException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, UploadNotFoundException.prototype);
     }
-}
-class InvalidTagParameterException extends ECRPUBLICServiceException {
+};
+let InvalidTagParameterException$1 = class InvalidTagParameterException extends ECRPUBLICServiceException$1 {
     name = "InvalidTagParameterException";
     $fault = "client";
     constructor(opts) {
@@ -265,8 +265,8 @@ class InvalidTagParameterException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, InvalidTagParameterException.prototype);
     }
-}
-class LimitExceededException extends ECRPUBLICServiceException {
+};
+let LimitExceededException$1 = class LimitExceededException extends ECRPUBLICServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     constructor(opts) {
@@ -277,8 +277,8 @@ class LimitExceededException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, LimitExceededException.prototype);
     }
-}
-class RepositoryAlreadyExistsException extends ECRPUBLICServiceException {
+};
+let RepositoryAlreadyExistsException$1 = class RepositoryAlreadyExistsException extends ECRPUBLICServiceException$1 {
     name = "RepositoryAlreadyExistsException";
     $fault = "client";
     constructor(opts) {
@@ -289,8 +289,8 @@ class RepositoryAlreadyExistsException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, RepositoryAlreadyExistsException.prototype);
     }
-}
-class TooManyTagsException extends ECRPUBLICServiceException {
+};
+let TooManyTagsException$1 = class TooManyTagsException extends ECRPUBLICServiceException$1 {
     name = "TooManyTagsException";
     $fault = "client";
     constructor(opts) {
@@ -301,8 +301,8 @@ class TooManyTagsException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, TooManyTagsException.prototype);
     }
-}
-class RepositoryNotEmptyException extends ECRPUBLICServiceException {
+};
+let RepositoryNotEmptyException$1 = class RepositoryNotEmptyException extends ECRPUBLICServiceException$1 {
     name = "RepositoryNotEmptyException";
     $fault = "client";
     constructor(opts) {
@@ -313,8 +313,8 @@ class RepositoryNotEmptyException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, RepositoryNotEmptyException.prototype);
     }
-}
-class RepositoryPolicyNotFoundException extends ECRPUBLICServiceException {
+};
+let RepositoryPolicyNotFoundException$1 = class RepositoryPolicyNotFoundException extends ECRPUBLICServiceException$1 {
     name = "RepositoryPolicyNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -325,8 +325,8 @@ class RepositoryPolicyNotFoundException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, RepositoryPolicyNotFoundException.prototype);
     }
-}
-class ImageNotFoundException extends ECRPUBLICServiceException {
+};
+let ImageNotFoundException$1 = class ImageNotFoundException extends ECRPUBLICServiceException$1 {
     name = "ImageNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -337,13 +337,13 @@ class ImageNotFoundException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, ImageNotFoundException.prototype);
     }
-}
+};
 const RegistryAliasStatus = {
     ACTIVE: "ACTIVE",
     PENDING: "PENDING",
     REJECTED: "REJECTED",
 };
-class RepositoryCatalogDataNotFoundException extends ECRPUBLICServiceException {
+let RepositoryCatalogDataNotFoundException$1 = class RepositoryCatalogDataNotFoundException extends ECRPUBLICServiceException$1 {
     name = "RepositoryCatalogDataNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -354,8 +354,8 @@ class RepositoryCatalogDataNotFoundException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, RepositoryCatalogDataNotFoundException.prototype);
     }
-}
-class ImageAlreadyExistsException extends ECRPUBLICServiceException {
+};
+let ImageAlreadyExistsException$1 = class ImageAlreadyExistsException extends ECRPUBLICServiceException$1 {
     name = "ImageAlreadyExistsException";
     $fault = "client";
     constructor(opts) {
@@ -366,8 +366,8 @@ class ImageAlreadyExistsException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, ImageAlreadyExistsException.prototype);
     }
-}
-class ImageDigestDoesNotMatchException extends ECRPUBLICServiceException {
+};
+let ImageDigestDoesNotMatchException$1 = class ImageDigestDoesNotMatchException extends ECRPUBLICServiceException$1 {
     name = "ImageDigestDoesNotMatchException";
     $fault = "client";
     constructor(opts) {
@@ -378,8 +378,8 @@ class ImageDigestDoesNotMatchException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, ImageDigestDoesNotMatchException.prototype);
     }
-}
-class ImageTagAlreadyExistsException extends ECRPUBLICServiceException {
+};
+let ImageTagAlreadyExistsException$1 = class ImageTagAlreadyExistsException extends ECRPUBLICServiceException$1 {
     name = "ImageTagAlreadyExistsException";
     $fault = "client";
     constructor(opts) {
@@ -390,8 +390,8 @@ class ImageTagAlreadyExistsException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, ImageTagAlreadyExistsException.prototype);
     }
-}
-class InvalidLayerPartException extends ECRPUBLICServiceException {
+};
+let InvalidLayerPartException$1 = class InvalidLayerPartException extends ECRPUBLICServiceException$1 {
     name = "InvalidLayerPartException";
     $fault = "client";
     registryId;
@@ -410,8 +410,8 @@ class InvalidLayerPartException extends ECRPUBLICServiceException {
         this.uploadId = opts.uploadId;
         this.lastValidByteReceived = opts.lastValidByteReceived;
     }
-}
-class LayersNotFoundException extends ECRPUBLICServiceException {
+};
+let LayersNotFoundException$1 = class LayersNotFoundException extends ECRPUBLICServiceException$1 {
     name = "LayersNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -422,8 +422,8 @@ class LayersNotFoundException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, LayersNotFoundException.prototype);
     }
-}
-class ReferencedImagesNotFoundException extends ECRPUBLICServiceException {
+};
+let ReferencedImagesNotFoundException$1 = class ReferencedImagesNotFoundException extends ECRPUBLICServiceException$1 {
     name = "ReferencedImagesNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -434,927 +434,896 @@ class ReferencedImagesNotFoundException extends ECRPUBLICServiceException {
         });
         Object.setPrototypeOf(this, ReferencedImagesNotFoundException.prototype);
     }
-}
-
-const se_BatchCheckLayerAvailabilityCommand = async (input, context) => {
-    const headers = sharedHeaders("BatchCheckLayerAvailability");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_BatchDeleteImageCommand = async (input, context) => {
-    const headers = sharedHeaders("BatchDeleteImage");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CompleteLayerUploadCommand = async (input, context) => {
-    const headers = sharedHeaders("CompleteLayerUpload");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateRepositoryCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateRepository");
-    let body;
-    body = JSON.stringify(se_CreateRepositoryRequest(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteRepositoryCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteRepository");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteRepositoryPolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteRepositoryPolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeImagesCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeImages");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeImageTagsCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeImageTags");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeRegistriesCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeRegistries");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeRepositoriesCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeRepositories");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetAuthorizationTokenCommand = async (input, context) => {
-    const headers = sharedHeaders("GetAuthorizationToken");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetRegistryCatalogDataCommand = async (input, context) => {
-    const headers = sharedHeaders("GetRegistryCatalogData");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetRepositoryCatalogDataCommand = async (input, context) => {
-    const headers = sharedHeaders("GetRepositoryCatalogData");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetRepositoryPolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("GetRepositoryPolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_InitiateLayerUploadCommand = async (input, context) => {
-    const headers = sharedHeaders("InitiateLayerUpload");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PutImageCommand = async (input, context) => {
-    const headers = sharedHeaders("PutImage");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PutRegistryCatalogDataCommand = async (input, context) => {
-    const headers = sharedHeaders("PutRegistryCatalogData");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PutRepositoryCatalogDataCommand = async (input, context) => {
-    const headers = sharedHeaders("PutRepositoryCatalogData");
-    let body;
-    body = JSON.stringify(se_PutRepositoryCatalogDataRequest(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SetRepositoryPolicyCommand = async (input, context) => {
-    const headers = sharedHeaders("SetRepositoryPolicy");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("TagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UploadLayerPartCommand = async (input, context) => {
-    const headers = sharedHeaders("UploadLayerPart");
-    let body;
-    body = JSON.stringify(se_UploadLayerPartRequest(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_BatchCheckLayerAvailabilityCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_BatchDeleteImageCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CompleteLayerUploadCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateRepositoryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateRepositoryResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteRepositoryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteRepositoryResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteRepositoryPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeImagesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeImagesResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeImageTagsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeImageTagsResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeRegistriesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeRepositoriesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeRepositoriesResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetAuthorizationTokenCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetAuthorizationTokenResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetRegistryCatalogDataCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetRepositoryCatalogDataCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetRepositoryPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_InitiateLayerUploadCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutImageCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutRegistryCatalogDataCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PutRepositoryCatalogDataCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_SetRepositoryPolicyCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UploadLayerPartCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidParameterException":
-        case "com.amazonaws.ecrpublic#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput);
-        case "RegistryNotFoundException":
-        case "com.amazonaws.ecrpublic#RegistryNotFoundException":
-            throw await de_RegistryNotFoundExceptionRes(parsedOutput);
-        case "RepositoryNotFoundException":
-        case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-            throw await de_RepositoryNotFoundExceptionRes(parsedOutput);
-        case "ServerException":
-        case "com.amazonaws.ecrpublic#ServerException":
-            throw await de_ServerExceptionRes(parsedOutput);
-        case "UnsupportedCommandException":
-        case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-            throw await de_UnsupportedCommandExceptionRes(parsedOutput);
-        case "EmptyUploadException":
-        case "com.amazonaws.ecrpublic#EmptyUploadException":
-            throw await de_EmptyUploadExceptionRes(parsedOutput);
-        case "InvalidLayerException":
-        case "com.amazonaws.ecrpublic#InvalidLayerException":
-            throw await de_InvalidLayerExceptionRes(parsedOutput);
-        case "LayerAlreadyExistsException":
-        case "com.amazonaws.ecrpublic#LayerAlreadyExistsException":
-            throw await de_LayerAlreadyExistsExceptionRes(parsedOutput);
-        case "LayerPartTooSmallException":
-        case "com.amazonaws.ecrpublic#LayerPartTooSmallException":
-            throw await de_LayerPartTooSmallExceptionRes(parsedOutput);
-        case "UploadNotFoundException":
-        case "com.amazonaws.ecrpublic#UploadNotFoundException":
-            throw await de_UploadNotFoundExceptionRes(parsedOutput);
-        case "InvalidTagParameterException":
-        case "com.amazonaws.ecrpublic#InvalidTagParameterException":
-            throw await de_InvalidTagParameterExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.ecrpublic#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        case "RepositoryAlreadyExistsException":
-        case "com.amazonaws.ecrpublic#RepositoryAlreadyExistsException":
-            throw await de_RepositoryAlreadyExistsExceptionRes(parsedOutput);
-        case "TooManyTagsException":
-        case "com.amazonaws.ecrpublic#TooManyTagsException":
-            throw await de_TooManyTagsExceptionRes(parsedOutput);
-        case "RepositoryNotEmptyException":
-        case "com.amazonaws.ecrpublic#RepositoryNotEmptyException":
-            throw await de_RepositoryNotEmptyExceptionRes(parsedOutput);
-        case "RepositoryPolicyNotFoundException":
-        case "com.amazonaws.ecrpublic#RepositoryPolicyNotFoundException":
-            throw await de_RepositoryPolicyNotFoundExceptionRes(parsedOutput);
-        case "ImageNotFoundException":
-        case "com.amazonaws.ecrpublic#ImageNotFoundException":
-            throw await de_ImageNotFoundExceptionRes(parsedOutput);
-        case "RepositoryCatalogDataNotFoundException":
-        case "com.amazonaws.ecrpublic#RepositoryCatalogDataNotFoundException":
-            throw await de_RepositoryCatalogDataNotFoundExceptionRes(parsedOutput);
-        case "ImageAlreadyExistsException":
-        case "com.amazonaws.ecrpublic#ImageAlreadyExistsException":
-            throw await de_ImageAlreadyExistsExceptionRes(parsedOutput);
-        case "ImageDigestDoesNotMatchException":
-        case "com.amazonaws.ecrpublic#ImageDigestDoesNotMatchException":
-            throw await de_ImageDigestDoesNotMatchExceptionRes(parsedOutput);
-        case "ImageTagAlreadyExistsException":
-        case "com.amazonaws.ecrpublic#ImageTagAlreadyExistsException":
-            throw await de_ImageTagAlreadyExistsExceptionRes(parsedOutput);
-        case "LayersNotFoundException":
-        case "com.amazonaws.ecrpublic#LayersNotFoundException":
-            throw await de_LayersNotFoundExceptionRes(parsedOutput);
-        case "ReferencedImagesNotFoundException":
-        case "com.amazonaws.ecrpublic#ReferencedImagesNotFoundException":
-            throw await de_ReferencedImagesNotFoundExceptionRes(parsedOutput);
-        case "InvalidLayerPartException":
-        case "com.amazonaws.ecrpublic#InvalidLayerPartException":
-            throw await de_InvalidLayerPartExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_EmptyUploadExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new EmptyUploadException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ImageAlreadyExistsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ImageAlreadyExistsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ImageDigestDoesNotMatchExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ImageDigestDoesNotMatchException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ImageNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ImageNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ImageTagAlreadyExistsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ImageTagAlreadyExistsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidLayerExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidLayerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidLayerPartExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidLayerPartException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidParameterExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidParameterException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidTagParameterExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidTagParameterException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LayerAlreadyExistsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LayerAlreadyExistsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LayerPartTooSmallExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LayerPartTooSmallException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LayersNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LayersNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ReferencedImagesNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ReferencedImagesNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_RegistryNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new RegistryNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_RepositoryAlreadyExistsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new RepositoryAlreadyExistsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_RepositoryCatalogDataNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new RepositoryCatalogDataNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_RepositoryNotEmptyExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new RepositoryNotEmptyException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_RepositoryNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new RepositoryNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_RepositoryPolicyNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new RepositoryPolicyNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ServerExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TooManyTagsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TooManyTagsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_UnsupportedCommandExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new UnsupportedCommandException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_UploadNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new UploadNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_CreateRepositoryRequest = (input, context) => {
-    return smithyClient.take(input, {
-        catalogData: (_) => se_RepositoryCatalogDataInput(_, context),
-        repositoryName: [],
-        tags: smithyClient._json,
-    });
-};
-const se_PutRepositoryCatalogDataRequest = (input, context) => {
-    return smithyClient.take(input, {
-        catalogData: (_) => se_RepositoryCatalogDataInput(_, context),
-        registryId: [],
-        repositoryName: [],
-    });
-};
-const se_RepositoryCatalogDataInput = (input, context) => {
-    return smithyClient.take(input, {
-        aboutText: [],
-        architectures: smithyClient._json,
-        description: [],
-        logoImageBlob: context.base64Encoder,
-        operatingSystems: smithyClient._json,
-        usageText: [],
-    });
-};
-const se_UploadLayerPartRequest = (input, context) => {
-    return smithyClient.take(input, {
-        layerPartBlob: context.base64Encoder,
-        partFirstByte: [],
-        partLastByte: [],
-        registryId: [],
-        repositoryName: [],
-        uploadId: [],
-    });
-};
-const de_AuthorizationData = (output, context) => {
-    return smithyClient.take(output, {
-        authorizationToken: smithyClient.expectString,
-        expiresAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_CreateRepositoryResponse = (output, context) => {
-    return smithyClient.take(output, {
-        catalogData: smithyClient._json,
-        repository: (_) => de_Repository(_),
-    });
-};
-const de_DeleteRepositoryResponse = (output, context) => {
-    return smithyClient.take(output, {
-        repository: (_) => de_Repository(_),
-    });
-};
-const de_DescribeImagesResponse = (output, context) => {
-    return smithyClient.take(output, {
-        imageDetails: (_) => de_ImageDetailList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_DescribeImageTagsResponse = (output, context) => {
-    return smithyClient.take(output, {
-        imageTagDetails: (_) => de_ImageTagDetailList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_DescribeRepositoriesResponse = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        repositories: (_) => de_RepositoryList(_),
-    });
-};
-const de_GetAuthorizationTokenResponse = (output, context) => {
-    return smithyClient.take(output, {
-        authorizationData: (_) => de_AuthorizationData(_),
-    });
-};
-const de_ImageDetail = (output, context) => {
-    return smithyClient.take(output, {
-        artifactMediaType: smithyClient.expectString,
-        imageDigest: smithyClient.expectString,
-        imageManifestMediaType: smithyClient.expectString,
-        imagePushedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        imageSizeInBytes: smithyClient.expectLong,
-        imageTags: smithyClient._json,
-        registryId: smithyClient.expectString,
-        repositoryName: smithyClient.expectString,
-    });
-};
-const de_ImageDetailList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ImageDetail(entry);
-    });
-    return retVal;
-};
-const de_ImageTagDetail = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        imageDetail: (_) => de_ReferencedImageDetail(_),
-        imageTag: smithyClient.expectString,
-    });
-};
-const de_ImageTagDetailList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ImageTagDetail(entry);
-    });
-    return retVal;
-};
-const de_ReferencedImageDetail = (output, context) => {
-    return smithyClient.take(output, {
-        artifactMediaType: smithyClient.expectString,
-        imageDigest: smithyClient.expectString,
-        imageManifestMediaType: smithyClient.expectString,
-        imagePushedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        imageSizeInBytes: smithyClient.expectLong,
-    });
-};
-const de_Repository = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        registryId: smithyClient.expectString,
-        repositoryArn: smithyClient.expectString,
-        repositoryName: smithyClient.expectString,
-        repositoryUri: smithyClient.expectString,
-    });
-};
-const de_RepositoryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Repository(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(ECRPUBLICServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
 };
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": `SpencerFrontendService.${operation}`,
-    };
-}
+
+const _AD = "AuthorizationData";
+const _BCLA = "BatchCheckLayerAvailability";
+const _BCLAR = "BatchCheckLayerAvailabilityRequest";
+const _BCLARa = "BatchCheckLayerAvailabilityResponse";
+const _BDI = "BatchDeleteImage";
+const _BDIR = "BatchDeleteImageRequest";
+const _BDIRa = "BatchDeleteImageResponse";
+const _CLU = "CompleteLayerUpload";
+const _CLUR = "CompleteLayerUploadRequest";
+const _CLURo = "CompleteLayerUploadResponse";
+const _CR = "CreateRepository";
+const _CRR = "CreateRepositoryRequest";
+const _CRRr = "CreateRepositoryResponse";
+const _DI = "DescribeImages";
+const _DIR = "DescribeImagesRequest";
+const _DIRe = "DescribeImagesResponse";
+const _DIT = "DescribeImageTags";
+const _DITR = "DescribeImageTagsRequest";
+const _DITRe = "DescribeImageTagsResponse";
+const _DR = "DeleteRepository";
+const _DRP = "DeleteRepositoryPolicy";
+const _DRPR = "DeleteRepositoryPolicyRequest";
+const _DRPRe = "DeleteRepositoryPolicyResponse";
+const _DRR = "DeleteRepositoryRequest";
+const _DRRe = "DeleteRepositoryResponse";
+const _DRRes = "DescribeRegistriesRequest";
+const _DRResc = "DescribeRegistriesResponse";
+const _DRRescr = "DescribeRepositoriesRequest";
+const _DRRescri = "DescribeRepositoriesResponse";
+const _DRe = "DescribeRegistries";
+const _DRes = "DescribeRepositories";
+const _EUE = "EmptyUploadException";
+const _GAT = "GetAuthorizationToken";
+const _GATR = "GetAuthorizationTokenRequest";
+const _GATRe = "GetAuthorizationTokenResponse";
+const _GRCD = "GetRegistryCatalogData";
+const _GRCDR = "GetRegistryCatalogDataRequest";
+const _GRCDRe = "GetRegistryCatalogDataResponse";
+const _GRCDRet = "GetRepositoryCatalogDataRequest";
+const _GRCDRete = "GetRepositoryCatalogDataResponse";
+const _GRCDe = "GetRepositoryCatalogData";
+const _GRP = "GetRepositoryPolicy";
+const _GRPR = "GetRepositoryPolicyRequest";
+const _GRPRe = "GetRepositoryPolicyResponse";
+const _I = "Image";
+const _IAEE = "ImageAlreadyExistsException";
+const _ID = "ImageDetail";
+const _IDDNME = "ImageDigestDoesNotMatchException";
+const _IDL = "ImageDetailList";
+const _IF = "ImageFailure";
+const _IFL = "ImageFailureList";
+const _II = "ImageIdentifier";
+const _IIL = "ImageIdentifierList";
+const _ILE = "InvalidLayerException";
+const _ILPE = "InvalidLayerPartException";
+const _ILU = "InitiateLayerUpload";
+const _ILUR = "InitiateLayerUploadRequest";
+const _ILURn = "InitiateLayerUploadResponse";
+const _INFE = "ImageNotFoundException";
+const _IPE = "InvalidParameterException";
+const _ITAEE = "ImageTagAlreadyExistsException";
+const _ITD = "ImageTagDetail";
+const _ITDL = "ImageTagDetailList";
+const _ITPE = "InvalidTagParameterException";
+const _K = "Key";
+const _L = "Layer";
+const _LAEE = "LayerAlreadyExistsException";
+const _LEE = "LimitExceededException";
+const _LF = "LayerFailure";
+const _LFL = "LayerFailureList";
+const _LL = "LayerList";
+const _LNFE = "LayersNotFoundException";
+const _LPTSE = "LayerPartTooSmallException";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _PI = "PutImage";
+const _PIR = "PutImageRequest";
+const _PIRu = "PutImageResponse";
+const _PRCD = "PutRegistryCatalogData";
+const _PRCDR = "PutRegistryCatalogDataRequest";
+const _PRCDRu = "PutRegistryCatalogDataResponse";
+const _PRCDRut = "PutRepositoryCatalogDataRequest";
+const _PRCDRute = "PutRepositoryCatalogDataResponse";
+const _PRCDu = "PutRepositoryCatalogData";
+const _R = "Registry";
+const _RA = "RegistryAlias";
+const _RAEE = "RepositoryAlreadyExistsException";
+const _RAL = "RegistryAliasList";
+const _RCD = "RegistryCatalogData";
+const _RCDI = "RepositoryCatalogDataInput";
+const _RCDNFE = "RepositoryCatalogDataNotFoundException";
+const _RCDe = "RepositoryCatalogData";
+const _RID = "ReferencedImageDetail";
+const _RINFE = "ReferencedImagesNotFoundException";
+const _RL = "RegistryList";
+const _RLe = "RepositoryList";
+const _RNEE = "RepositoryNotEmptyException";
+const _RNFE = "RegistryNotFoundException";
+const _RNFEe = "RepositoryNotFoundException";
+const _RPNFE = "RepositoryPolicyNotFoundException";
+const _Re = "Repository";
+const _SE = "ServerException";
+const _SRP = "SetRepositoryPolicy";
+const _SRPR = "SetRepositoryPolicyRequest";
+const _SRPRe = "SetRepositoryPolicyResponse";
+const _T = "Tag";
+const _TL = "TagList";
+const _TMTE = "TooManyTagsException";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UCE = "UnsupportedCommandException";
+const _ULP = "UploadLayerPart";
+const _ULPR = "UploadLayerPartRequest";
+const _ULPRp = "UploadLayerPartResponse";
+const _UNFE = "UploadNotFoundException";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _V = "Value";
+const _a = "aliases";
+const _aD = "authorizationData";
+const _aMT = "artifactMediaType";
+const _aT = "authorizationToken";
+const _aTb = "aboutText";
+const _ar = "architectures";
+const _c = "client";
+const _cA = "createdAt";
+const _cD = "catalogData";
+const _d = "description";
+const _dN = "displayName";
+const _dRA = "defaultRegistryAlias";
+const _e = "error";
+const _eA = "expiresAt";
+const _f = "failures";
+const _fC = "failureCode";
+const _fR = "failureReason";
+const _fo = "force";
+const _i = "image";
+const _iD = "imageDetails";
+const _iDm = "imageDigest";
+const _iDma = "imageDetail";
+const _iI = "imageIds";
+const _iIm = "imageId";
+const _iM = "imageManifest";
+const _iMMT = "imageManifestMediaType";
+const _iPA = "imagePushedAt";
+const _iSIB = "imageSizeInBytes";
+const _iT = "imageTags";
+const _iTD = "imageTagDetails";
+const _iTm = "imageTag";
+const _l = "layers";
+const _lA = "layerAvailability";
+const _lBR = "lastByteReceived";
+const _lD = "layerDigests";
+const _lDa = "layerDigest";
+const _lIB = "logoImageBlob";
+const _lPB = "layerPartBlob";
+const _lS = "layerSize";
+const _lU = "logoUrl";
+const _lVBR = "lastValidByteReceived";
+const _m = "message";
+const _mC = "marketplaceCertified";
+const _mR = "maxResults";
+const _mT = "mediaType";
+const _n = "name";
+const _nT = "nextToken";
+const _oS = "operatingSystems";
+const _pFB = "partFirstByte";
+const _pLB = "partLastByte";
+const _pRA = "primaryRegistryAlias";
+const _pS = "partSize";
+const _pT = "policyText";
+const _r = "repository";
+const _rA = "resourceArn";
+const _rAe = "registryArn";
+const _rAep = "repositoryArn";
+const _rCD = "registryCatalogData";
+const _rI = "registryId";
+const _rN = "repositoryName";
+const _rNe = "repositoryNames";
+const _rU = "registryUri";
+const _rUe = "repositoryUri";
+const _re = "registries";
+const _rep = "repositories";
+const _s = "status";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.ecrpublic";
+const _t = "tags";
+const _tK = "tagKeys";
+const _uI = "uploadId";
+const _uT = "usageText";
+const _v = "verified";
+const n0 = "com.amazonaws.ecrpublic";
+var AuthorizationData = [3, n0, _AD, 0, [_aT, _eA], [0, 4]];
+var BatchCheckLayerAvailabilityRequest = [
+    3,
+    n0,
+    _BCLAR,
+    0,
+    [_rI, _rN, _lD],
+    [0, 0, 64 | 0],
+];
+var BatchCheckLayerAvailabilityResponse = [
+    3,
+    n0,
+    _BCLARa,
+    0,
+    [_l, _f],
+    [() => LayerList, () => LayerFailureList],
+];
+var BatchDeleteImageRequest = [
+    3,
+    n0,
+    _BDIR,
+    0,
+    [_rI, _rN, _iI],
+    [0, 0, () => ImageIdentifierList],
+];
+var BatchDeleteImageResponse = [
+    3,
+    n0,
+    _BDIRa,
+    0,
+    [_iI, _f],
+    [() => ImageIdentifierList, () => ImageFailureList],
+];
+var CompleteLayerUploadRequest = [
+    3,
+    n0,
+    _CLUR,
+    0,
+    [_rI, _rN, _uI, _lD],
+    [0, 0, 0, 64 | 0],
+];
+var CompleteLayerUploadResponse = [3, n0, _CLURo, 0, [_rI, _rN, _uI, _lDa], [0, 0, 0, 0]];
+var CreateRepositoryRequest = [
+    3,
+    n0,
+    _CRR,
+    0,
+    [_rN, _cD, _t],
+    [0, () => RepositoryCatalogDataInput, () => TagList],
+];
+var CreateRepositoryResponse = [
+    3,
+    n0,
+    _CRRr,
+    0,
+    [_r, _cD],
+    [() => Repository, () => RepositoryCatalogData],
+];
+var DeleteRepositoryPolicyRequest = [3, n0, _DRPR, 0, [_rI, _rN], [0, 0]];
+var DeleteRepositoryPolicyResponse = [3, n0, _DRPRe, 0, [_rI, _rN, _pT], [0, 0, 0]];
+var DeleteRepositoryRequest = [3, n0, _DRR, 0, [_rI, _rN, _fo], [0, 0, 2]];
+var DeleteRepositoryResponse = [3, n0, _DRRe, 0, [_r], [() => Repository]];
+var DescribeImagesRequest = [
+    3,
+    n0,
+    _DIR,
+    0,
+    [_rI, _rN, _iI, _nT, _mR],
+    [0, 0, () => ImageIdentifierList, 0, 1],
+];
+var DescribeImagesResponse = [3, n0, _DIRe, 0, [_iD, _nT], [() => ImageDetailList, 0]];
+var DescribeImageTagsRequest = [3, n0, _DITR, 0, [_rI, _rN, _nT, _mR], [0, 0, 0, 1]];
+var DescribeImageTagsResponse = [
+    3,
+    n0,
+    _DITRe,
+    0,
+    [_iTD, _nT],
+    [() => ImageTagDetailList, 0],
+];
+var DescribeRegistriesRequest = [3, n0, _DRRes, 0, [_nT, _mR], [0, 1]];
+var DescribeRegistriesResponse = [3, n0, _DRResc, 0, [_re, _nT], [() => RegistryList, 0]];
+var DescribeRepositoriesRequest = [
+    3,
+    n0,
+    _DRRescr,
+    0,
+    [_rI, _rNe, _nT, _mR],
+    [0, 64 | 0, 0, 1],
+];
+var DescribeRepositoriesResponse = [
+    3,
+    n0,
+    _DRRescri,
+    0,
+    [_rep, _nT],
+    [() => RepositoryList, 0],
+];
+var EmptyUploadException = [
+    -3,
+    n0,
+    _EUE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(EmptyUploadException, EmptyUploadException$1);
+var GetAuthorizationTokenRequest = [3, n0, _GATR, 0, [], []];
+var GetAuthorizationTokenResponse = [3, n0, _GATRe, 0, [_aD], [() => AuthorizationData]];
+var GetRegistryCatalogDataRequest = [3, n0, _GRCDR, 0, [], []];
+var GetRegistryCatalogDataResponse = [
+    3,
+    n0,
+    _GRCDRe,
+    0,
+    [_rCD],
+    [() => RegistryCatalogData],
+];
+var GetRepositoryCatalogDataRequest = [3, n0, _GRCDRet, 0, [_rI, _rN], [0, 0]];
+var GetRepositoryCatalogDataResponse = [
+    3,
+    n0,
+    _GRCDRete,
+    0,
+    [_cD],
+    [() => RepositoryCatalogData],
+];
+var GetRepositoryPolicyRequest = [3, n0, _GRPR, 0, [_rI, _rN], [0, 0]];
+var GetRepositoryPolicyResponse = [3, n0, _GRPRe, 0, [_rI, _rN, _pT], [0, 0, 0]];
+var Image = [
+    3,
+    n0,
+    _I,
+    0,
+    [_rI, _rN, _iIm, _iM, _iMMT],
+    [0, 0, () => ImageIdentifier, 0, 0],
+];
+var ImageAlreadyExistsException = [
+    -3,
+    n0,
+    _IAEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ImageAlreadyExistsException, ImageAlreadyExistsException$1);
+var ImageDetail = [
+    3,
+    n0,
+    _ID,
+    0,
+    [_rI, _rN, _iDm, _iT, _iSIB, _iPA, _iMMT, _aMT],
+    [0, 0, 0, 64 | 0, 1, 4, 0, 0],
+];
+var ImageDigestDoesNotMatchException = [
+    -3,
+    n0,
+    _IDDNME,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ImageDigestDoesNotMatchException, ImageDigestDoesNotMatchException$1);
+var ImageFailure = [3, n0, _IF, 0, [_iIm, _fC, _fR], [() => ImageIdentifier, 0, 0]];
+var ImageIdentifier = [3, n0, _II, 0, [_iDm, _iTm], [0, 0]];
+var ImageNotFoundException = [
+    -3,
+    n0,
+    _INFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ImageNotFoundException, ImageNotFoundException$1);
+var ImageTagAlreadyExistsException = [
+    -3,
+    n0,
+    _ITAEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ImageTagAlreadyExistsException, ImageTagAlreadyExistsException$1);
+var ImageTagDetail = [
+    3,
+    n0,
+    _ITD,
+    0,
+    [_iTm, _cA, _iDma],
+    [0, 4, () => ReferencedImageDetail],
+];
+var InitiateLayerUploadRequest = [3, n0, _ILUR, 0, [_rI, _rN], [0, 0]];
+var InitiateLayerUploadResponse = [3, n0, _ILURn, 0, [_uI, _pS], [0, 1]];
+var InvalidLayerException = [
+    -3,
+    n0,
+    _ILE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidLayerException, InvalidLayerException$1);
+var InvalidLayerPartException = [
+    -3,
+    n0,
+    _ILPE,
+    {
+        [_e]: _c,
+    },
+    [_rI, _rN, _uI, _lVBR, _m],
+    [0, 0, 0, 1, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidLayerPartException, InvalidLayerPartException$1);
+var InvalidParameterException = [
+    -3,
+    n0,
+    _IPE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidParameterException, InvalidParameterException$1);
+var InvalidTagParameterException = [
+    -3,
+    n0,
+    _ITPE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidTagParameterException, InvalidTagParameterException$1);
+var Layer = [3, n0, _L, 0, [_lDa, _lA, _lS, _mT], [0, 0, 1, 0]];
+var LayerAlreadyExistsException = [
+    -3,
+    n0,
+    _LAEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LayerAlreadyExistsException, LayerAlreadyExistsException$1);
+var LayerFailure = [3, n0, _LF, 0, [_lDa, _fC, _fR], [0, 0, 0]];
+var LayerPartTooSmallException = [
+    -3,
+    n0,
+    _LPTSE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LayerPartTooSmallException, LayerPartTooSmallException$1);
+var LayersNotFoundException = [
+    -3,
+    n0,
+    _LNFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LayersNotFoundException, LayersNotFoundException$1);
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rA], [0]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_t], [() => TagList]];
+var PutImageRequest = [
+    3,
+    n0,
+    _PIR,
+    0,
+    [_rI, _rN, _iM, _iMMT, _iTm, _iDm],
+    [0, 0, 0, 0, 0, 0],
+];
+var PutImageResponse = [3, n0, _PIRu, 0, [_i], [() => Image]];
+var PutRegistryCatalogDataRequest = [3, n0, _PRCDR, 0, [_dN], [0]];
+var PutRegistryCatalogDataResponse = [
+    3,
+    n0,
+    _PRCDRu,
+    0,
+    [_rCD],
+    [() => RegistryCatalogData],
+];
+var PutRepositoryCatalogDataRequest = [
+    3,
+    n0,
+    _PRCDRut,
+    0,
+    [_rI, _rN, _cD],
+    [0, 0, () => RepositoryCatalogDataInput],
+];
+var PutRepositoryCatalogDataResponse = [
+    3,
+    n0,
+    _PRCDRute,
+    0,
+    [_cD],
+    [() => RepositoryCatalogData],
+];
+var ReferencedImageDetail = [
+    3,
+    n0,
+    _RID,
+    0,
+    [_iDm, _iSIB, _iPA, _iMMT, _aMT],
+    [0, 1, 4, 0, 0],
+];
+var ReferencedImagesNotFoundException = [
+    -3,
+    n0,
+    _RINFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ReferencedImagesNotFoundException, ReferencedImagesNotFoundException$1);
+var Registry = [
+    3,
+    n0,
+    _R,
+    0,
+    [_rI, _rAe, _rU, _v, _a],
+    [0, 0, 0, 2, () => RegistryAliasList],
+];
+var RegistryAlias = [3, n0, _RA, 0, [_n, _s, _pRA, _dRA], [0, 0, 2, 2]];
+var RegistryCatalogData = [3, n0, _RCD, 0, [_dN], [0]];
+var RegistryNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RegistryNotFoundException, RegistryNotFoundException$1);
+var Repository = [3, n0, _Re, 0, [_rAep, _rI, _rN, _rUe, _cA], [0, 0, 0, 0, 4]];
+var RepositoryAlreadyExistsException = [
+    -3,
+    n0,
+    _RAEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RepositoryAlreadyExistsException, RepositoryAlreadyExistsException$1);
+var RepositoryCatalogData = [
+    3,
+    n0,
+    _RCDe,
+    0,
+    [_d, _ar, _oS, _lU, _aTb, _uT, _mC],
+    [0, 64 | 0, 64 | 0, 0, 0, 0, 2],
+];
+var RepositoryCatalogDataInput = [
+    3,
+    n0,
+    _RCDI,
+    0,
+    [_d, _ar, _oS, _lIB, _aTb, _uT],
+    [0, 64 | 0, 64 | 0, 21, 0, 0],
+];
+var RepositoryCatalogDataNotFoundException = [
+    -3,
+    n0,
+    _RCDNFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RepositoryCatalogDataNotFoundException, RepositoryCatalogDataNotFoundException$1);
+var RepositoryNotEmptyException = [
+    -3,
+    n0,
+    _RNEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RepositoryNotEmptyException, RepositoryNotEmptyException$1);
+var RepositoryNotFoundException = [
+    -3,
+    n0,
+    _RNFEe,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RepositoryNotFoundException, RepositoryNotFoundException$1);
+var RepositoryPolicyNotFoundException = [
+    -3,
+    n0,
+    _RPNFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(RepositoryPolicyNotFoundException, RepositoryPolicyNotFoundException$1);
+var ServerException = [
+    -3,
+    n0,
+    _SE,
+    {
+        [_e]: _se,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServerException, ServerException$1);
+var SetRepositoryPolicyRequest = [3, n0, _SRPR, 0, [_rI, _rN, _pT, _fo], [0, 0, 0, 2]];
+var SetRepositoryPolicyResponse = [3, n0, _SRPRe, 0, [_rI, _rN, _pT], [0, 0, 0]];
+var Tag = [3, n0, _T, 0, [_K, _V], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_rA, _t], [0, () => TagList]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var TooManyTagsException = [
+    -3,
+    n0,
+    _TMTE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyTagsException, TooManyTagsException$1);
+var UnsupportedCommandException = [
+    -3,
+    n0,
+    _UCE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UnsupportedCommandException, UnsupportedCommandException$1);
+var UntagResourceRequest = [3, n0, _URR, 0, [_rA, _tK], [0, 64 | 0]];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UploadLayerPartRequest = [
+    3,
+    n0,
+    _ULPR,
+    0,
+    [_rI, _rN, _uI, _pFB, _pLB, _lPB],
+    [0, 0, 0, 1, 1, 21],
+];
+var UploadLayerPartResponse = [3, n0, _ULPRp, 0, [_rI, _rN, _uI, _lBR], [0, 0, 0, 1]];
+var UploadNotFoundException = [
+    -3,
+    n0,
+    _UNFE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UploadNotFoundException, UploadNotFoundException$1);
+var ECRPUBLICServiceException = [-3, _sm, "ECRPUBLICServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(ECRPUBLICServiceException, ECRPUBLICServiceException$1);
+var ImageDetailList = [1, n0, _IDL, 0, () => ImageDetail];
+var ImageFailureList = [1, n0, _IFL, 0, () => ImageFailure];
+var ImageIdentifierList = [1, n0, _IIL, 0, () => ImageIdentifier];
+var ImageTagDetailList = [1, n0, _ITDL, 0, () => ImageTagDetail];
+var LayerFailureList = [1, n0, _LFL, 0, () => LayerFailure];
+var LayerList = [1, n0, _LL, 0, () => Layer];
+var RegistryAliasList = [1, n0, _RAL, 0, () => RegistryAlias];
+var RegistryList = [1, n0, _RL, 0, () => Registry];
+var RepositoryList = [1, n0, _RLe, 0, () => Repository];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var BatchCheckLayerAvailability = [
+    9,
+    n0,
+    _BCLA,
+    0,
+    () => BatchCheckLayerAvailabilityRequest,
+    () => BatchCheckLayerAvailabilityResponse,
+];
+var BatchDeleteImage = [
+    9,
+    n0,
+    _BDI,
+    0,
+    () => BatchDeleteImageRequest,
+    () => BatchDeleteImageResponse,
+];
+var CompleteLayerUpload = [
+    9,
+    n0,
+    _CLU,
+    0,
+    () => CompleteLayerUploadRequest,
+    () => CompleteLayerUploadResponse,
+];
+var CreateRepository = [
+    9,
+    n0,
+    _CR,
+    0,
+    () => CreateRepositoryRequest,
+    () => CreateRepositoryResponse,
+];
+var DeleteRepository = [
+    9,
+    n0,
+    _DR,
+    0,
+    () => DeleteRepositoryRequest,
+    () => DeleteRepositoryResponse,
+];
+var DeleteRepositoryPolicy = [
+    9,
+    n0,
+    _DRP,
+    0,
+    () => DeleteRepositoryPolicyRequest,
+    () => DeleteRepositoryPolicyResponse,
+];
+var DescribeImages = [
+    9,
+    n0,
+    _DI,
+    0,
+    () => DescribeImagesRequest,
+    () => DescribeImagesResponse,
+];
+var DescribeImageTags = [
+    9,
+    n0,
+    _DIT,
+    0,
+    () => DescribeImageTagsRequest,
+    () => DescribeImageTagsResponse,
+];
+var DescribeRegistries = [
+    9,
+    n0,
+    _DRe,
+    0,
+    () => DescribeRegistriesRequest,
+    () => DescribeRegistriesResponse,
+];
+var DescribeRepositories = [
+    9,
+    n0,
+    _DRes,
+    0,
+    () => DescribeRepositoriesRequest,
+    () => DescribeRepositoriesResponse,
+];
+var GetAuthorizationToken = [
+    9,
+    n0,
+    _GAT,
+    0,
+    () => GetAuthorizationTokenRequest,
+    () => GetAuthorizationTokenResponse,
+];
+var GetRegistryCatalogData = [
+    9,
+    n0,
+    _GRCD,
+    0,
+    () => GetRegistryCatalogDataRequest,
+    () => GetRegistryCatalogDataResponse,
+];
+var GetRepositoryCatalogData = [
+    9,
+    n0,
+    _GRCDe,
+    0,
+    () => GetRepositoryCatalogDataRequest,
+    () => GetRepositoryCatalogDataResponse,
+];
+var GetRepositoryPolicy = [
+    9,
+    n0,
+    _GRP,
+    0,
+    () => GetRepositoryPolicyRequest,
+    () => GetRepositoryPolicyResponse,
+];
+var InitiateLayerUpload = [
+    9,
+    n0,
+    _ILU,
+    0,
+    () => InitiateLayerUploadRequest,
+    () => InitiateLayerUploadResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    0,
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var PutImage = [9, n0, _PI, 0, () => PutImageRequest, () => PutImageResponse];
+var PutRegistryCatalogData = [
+    9,
+    n0,
+    _PRCD,
+    0,
+    () => PutRegistryCatalogDataRequest,
+    () => PutRegistryCatalogDataResponse,
+];
+var PutRepositoryCatalogData = [
+    9,
+    n0,
+    _PRCDu,
+    0,
+    () => PutRepositoryCatalogDataRequest,
+    () => PutRepositoryCatalogDataResponse,
+];
+var SetRepositoryPolicy = [
+    9,
+    n0,
+    _SRP,
+    0,
+    () => SetRepositoryPolicyRequest,
+    () => SetRepositoryPolicyResponse,
+];
+var TagResource = [9, n0, _TR, 0, () => TagResourceRequest, () => TagResourceResponse];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    0,
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UploadLayerPart = [
+    9,
+    n0,
+    _ULP,
+    0,
+    () => UploadLayerPartRequest,
+    () => UploadLayerPartResponse,
+];
 
 class BatchCheckLayerAvailabilityCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "BatchCheckLayerAvailability", {})
     .n("ECRPUBLICClient", "BatchCheckLayerAvailabilityCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchCheckLayerAvailabilityCommand)
-    .de(de_BatchCheckLayerAvailabilityCommand)
+    .sc(BatchCheckLayerAvailability)
     .build() {
 }
 
@@ -1362,16 +1331,11 @@ class BatchDeleteImageCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "BatchDeleteImage", {})
     .n("ECRPUBLICClient", "BatchDeleteImageCommand")
-    .f(void 0, void 0)
-    .ser(se_BatchDeleteImageCommand)
-    .de(de_BatchDeleteImageCommand)
+    .sc(BatchDeleteImage)
     .build() {
 }
 
@@ -1379,16 +1343,11 @@ class CompleteLayerUploadCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "CompleteLayerUpload", {})
     .n("ECRPUBLICClient", "CompleteLayerUploadCommand")
-    .f(void 0, void 0)
-    .ser(se_CompleteLayerUploadCommand)
-    .de(de_CompleteLayerUploadCommand)
+    .sc(CompleteLayerUpload)
     .build() {
 }
 
@@ -1396,16 +1355,11 @@ class CreateRepositoryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "CreateRepository", {})
     .n("ECRPUBLICClient", "CreateRepositoryCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateRepositoryCommand)
-    .de(de_CreateRepositoryCommand)
+    .sc(CreateRepository)
     .build() {
 }
 
@@ -1413,16 +1367,11 @@ class DeleteRepositoryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "DeleteRepository", {})
     .n("ECRPUBLICClient", "DeleteRepositoryCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteRepositoryCommand)
-    .de(de_DeleteRepositoryCommand)
+    .sc(DeleteRepository)
     .build() {
 }
 
@@ -1430,16 +1379,11 @@ class DeleteRepositoryPolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "DeleteRepositoryPolicy", {})
     .n("ECRPUBLICClient", "DeleteRepositoryPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteRepositoryPolicyCommand)
-    .de(de_DeleteRepositoryPolicyCommand)
+    .sc(DeleteRepositoryPolicy)
     .build() {
 }
 
@@ -1447,16 +1391,11 @@ class DescribeImagesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "DescribeImages", {})
     .n("ECRPUBLICClient", "DescribeImagesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeImagesCommand)
-    .de(de_DescribeImagesCommand)
+    .sc(DescribeImages)
     .build() {
 }
 
@@ -1464,16 +1403,11 @@ class DescribeImageTagsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "DescribeImageTags", {})
     .n("ECRPUBLICClient", "DescribeImageTagsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeImageTagsCommand)
-    .de(de_DescribeImageTagsCommand)
+    .sc(DescribeImageTags)
     .build() {
 }
 
@@ -1481,16 +1415,11 @@ class DescribeRegistriesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "DescribeRegistries", {})
     .n("ECRPUBLICClient", "DescribeRegistriesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeRegistriesCommand)
-    .de(de_DescribeRegistriesCommand)
+    .sc(DescribeRegistries)
     .build() {
 }
 
@@ -1498,16 +1427,11 @@ class DescribeRepositoriesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "DescribeRepositories", {})
     .n("ECRPUBLICClient", "DescribeRepositoriesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeRepositoriesCommand)
-    .de(de_DescribeRepositoriesCommand)
+    .sc(DescribeRepositories)
     .build() {
 }
 
@@ -1515,16 +1439,11 @@ class GetAuthorizationTokenCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "GetAuthorizationToken", {})
     .n("ECRPUBLICClient", "GetAuthorizationTokenCommand")
-    .f(void 0, void 0)
-    .ser(se_GetAuthorizationTokenCommand)
-    .de(de_GetAuthorizationTokenCommand)
+    .sc(GetAuthorizationToken)
     .build() {
 }
 
@@ -1532,16 +1451,11 @@ class GetRegistryCatalogDataCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "GetRegistryCatalogData", {})
     .n("ECRPUBLICClient", "GetRegistryCatalogDataCommand")
-    .f(void 0, void 0)
-    .ser(se_GetRegistryCatalogDataCommand)
-    .de(de_GetRegistryCatalogDataCommand)
+    .sc(GetRegistryCatalogData)
     .build() {
 }
 
@@ -1549,16 +1463,11 @@ class GetRepositoryCatalogDataCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "GetRepositoryCatalogData", {})
     .n("ECRPUBLICClient", "GetRepositoryCatalogDataCommand")
-    .f(void 0, void 0)
-    .ser(se_GetRepositoryCatalogDataCommand)
-    .de(de_GetRepositoryCatalogDataCommand)
+    .sc(GetRepositoryCatalogData)
     .build() {
 }
 
@@ -1566,16 +1475,11 @@ class GetRepositoryPolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "GetRepositoryPolicy", {})
     .n("ECRPUBLICClient", "GetRepositoryPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_GetRepositoryPolicyCommand)
-    .de(de_GetRepositoryPolicyCommand)
+    .sc(GetRepositoryPolicy)
     .build() {
 }
 
@@ -1583,16 +1487,11 @@ class InitiateLayerUploadCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "InitiateLayerUpload", {})
     .n("ECRPUBLICClient", "InitiateLayerUploadCommand")
-    .f(void 0, void 0)
-    .ser(se_InitiateLayerUploadCommand)
-    .de(de_InitiateLayerUploadCommand)
+    .sc(InitiateLayerUpload)
     .build() {
 }
 
@@ -1600,16 +1499,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "ListTagsForResource", {})
     .n("ECRPUBLICClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1617,16 +1511,11 @@ class PutImageCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "PutImage", {})
     .n("ECRPUBLICClient", "PutImageCommand")
-    .f(void 0, void 0)
-    .ser(se_PutImageCommand)
-    .de(de_PutImageCommand)
+    .sc(PutImage)
     .build() {
 }
 
@@ -1634,16 +1523,11 @@ class PutRegistryCatalogDataCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "PutRegistryCatalogData", {})
     .n("ECRPUBLICClient", "PutRegistryCatalogDataCommand")
-    .f(void 0, void 0)
-    .ser(se_PutRegistryCatalogDataCommand)
-    .de(de_PutRegistryCatalogDataCommand)
+    .sc(PutRegistryCatalogData)
     .build() {
 }
 
@@ -1651,16 +1535,11 @@ class PutRepositoryCatalogDataCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "PutRepositoryCatalogData", {})
     .n("ECRPUBLICClient", "PutRepositoryCatalogDataCommand")
-    .f(void 0, void 0)
-    .ser(se_PutRepositoryCatalogDataCommand)
-    .de(de_PutRepositoryCatalogDataCommand)
+    .sc(PutRepositoryCatalogData)
     .build() {
 }
 
@@ -1668,16 +1547,11 @@ class SetRepositoryPolicyCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "SetRepositoryPolicy", {})
     .n("ECRPUBLICClient", "SetRepositoryPolicyCommand")
-    .f(void 0, void 0)
-    .ser(se_SetRepositoryPolicyCommand)
-    .de(de_SetRepositoryPolicyCommand)
+    .sc(SetRepositoryPolicy)
     .build() {
 }
 
@@ -1685,16 +1559,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "TagResource", {})
     .n("ECRPUBLICClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1702,16 +1571,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "UntagResource", {})
     .n("ECRPUBLICClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1719,16 +1583,11 @@ class UploadLayerPartCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SpencerFrontendService", "UploadLayerPart", {})
     .n("ECRPUBLICClient", "UploadLayerPartCommand")
-    .f(void 0, void 0)
-    .ser(se_UploadLayerPartCommand)
-    .de(de_UploadLayerPartCommand)
+    .sc(UploadLayerPart)
     .build() {
 }
 
@@ -1789,48 +1648,48 @@ exports.DescribeRegistriesCommand = DescribeRegistriesCommand;
 exports.DescribeRepositoriesCommand = DescribeRepositoriesCommand;
 exports.ECRPUBLIC = ECRPUBLIC;
 exports.ECRPUBLICClient = ECRPUBLICClient;
-exports.ECRPUBLICServiceException = ECRPUBLICServiceException;
-exports.EmptyUploadException = EmptyUploadException;
+exports.ECRPUBLICServiceException = ECRPUBLICServiceException$1;
+exports.EmptyUploadException = EmptyUploadException$1;
 exports.GetAuthorizationTokenCommand = GetAuthorizationTokenCommand;
 exports.GetRegistryCatalogDataCommand = GetRegistryCatalogDataCommand;
 exports.GetRepositoryCatalogDataCommand = GetRepositoryCatalogDataCommand;
 exports.GetRepositoryPolicyCommand = GetRepositoryPolicyCommand;
-exports.ImageAlreadyExistsException = ImageAlreadyExistsException;
-exports.ImageDigestDoesNotMatchException = ImageDigestDoesNotMatchException;
+exports.ImageAlreadyExistsException = ImageAlreadyExistsException$1;
+exports.ImageDigestDoesNotMatchException = ImageDigestDoesNotMatchException$1;
 exports.ImageFailureCode = ImageFailureCode;
-exports.ImageNotFoundException = ImageNotFoundException;
-exports.ImageTagAlreadyExistsException = ImageTagAlreadyExistsException;
+exports.ImageNotFoundException = ImageNotFoundException$1;
+exports.ImageTagAlreadyExistsException = ImageTagAlreadyExistsException$1;
 exports.InitiateLayerUploadCommand = InitiateLayerUploadCommand;
-exports.InvalidLayerException = InvalidLayerException;
-exports.InvalidLayerPartException = InvalidLayerPartException;
-exports.InvalidParameterException = InvalidParameterException;
-exports.InvalidTagParameterException = InvalidTagParameterException;
-exports.LayerAlreadyExistsException = LayerAlreadyExistsException;
+exports.InvalidLayerException = InvalidLayerException$1;
+exports.InvalidLayerPartException = InvalidLayerPartException$1;
+exports.InvalidParameterException = InvalidParameterException$1;
+exports.InvalidTagParameterException = InvalidTagParameterException$1;
+exports.LayerAlreadyExistsException = LayerAlreadyExistsException$1;
 exports.LayerAvailability = LayerAvailability;
 exports.LayerFailureCode = LayerFailureCode;
-exports.LayerPartTooSmallException = LayerPartTooSmallException;
-exports.LayersNotFoundException = LayersNotFoundException;
-exports.LimitExceededException = LimitExceededException;
+exports.LayerPartTooSmallException = LayerPartTooSmallException$1;
+exports.LayersNotFoundException = LayersNotFoundException$1;
+exports.LimitExceededException = LimitExceededException$1;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.PutImageCommand = PutImageCommand;
 exports.PutRegistryCatalogDataCommand = PutRegistryCatalogDataCommand;
 exports.PutRepositoryCatalogDataCommand = PutRepositoryCatalogDataCommand;
-exports.ReferencedImagesNotFoundException = ReferencedImagesNotFoundException;
+exports.ReferencedImagesNotFoundException = ReferencedImagesNotFoundException$1;
 exports.RegistryAliasStatus = RegistryAliasStatus;
-exports.RegistryNotFoundException = RegistryNotFoundException;
-exports.RepositoryAlreadyExistsException = RepositoryAlreadyExistsException;
-exports.RepositoryCatalogDataNotFoundException = RepositoryCatalogDataNotFoundException;
-exports.RepositoryNotEmptyException = RepositoryNotEmptyException;
-exports.RepositoryNotFoundException = RepositoryNotFoundException;
-exports.RepositoryPolicyNotFoundException = RepositoryPolicyNotFoundException;
-exports.ServerException = ServerException;
+exports.RegistryNotFoundException = RegistryNotFoundException$1;
+exports.RepositoryAlreadyExistsException = RepositoryAlreadyExistsException$1;
+exports.RepositoryCatalogDataNotFoundException = RepositoryCatalogDataNotFoundException$1;
+exports.RepositoryNotEmptyException = RepositoryNotEmptyException$1;
+exports.RepositoryNotFoundException = RepositoryNotFoundException$1;
+exports.RepositoryPolicyNotFoundException = RepositoryPolicyNotFoundException$1;
+exports.ServerException = ServerException$1;
 exports.SetRepositoryPolicyCommand = SetRepositoryPolicyCommand;
 exports.TagResourceCommand = TagResourceCommand;
-exports.TooManyTagsException = TooManyTagsException;
-exports.UnsupportedCommandException = UnsupportedCommandException;
+exports.TooManyTagsException = TooManyTagsException$1;
+exports.UnsupportedCommandException = UnsupportedCommandException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UploadLayerPartCommand = UploadLayerPartCommand;
-exports.UploadNotFoundException = UploadNotFoundException;
+exports.UploadNotFoundException = UploadNotFoundException$1;
 exports.paginateDescribeImageTags = paginateDescribeImageTags;
 exports.paginateDescribeImages = paginateDescribeImages;
 exports.paginateDescribeRegistries = paginateDescribeRegistries;