npm - @aws-sdk/client-ecr-public - Versions diffs - 3.901.0 → 3.907.0 - Mend

@aws-sdk/client-ecr-public 3.901.0 → 3.907.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist-cjs/index.js +1754 -2010
package/package.json +6 -6

package/dist-cjs/index.js CHANGED Viewed

@@ -1,2093 +1,1837 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  BatchCheckLayerAvailabilityCommand: () => BatchCheckLayerAvailabilityCommand,
-  BatchDeleteImageCommand: () => BatchDeleteImageCommand,
-  CompleteLayerUploadCommand: () => CompleteLayerUploadCommand,
-  CreateRepositoryCommand: () => CreateRepositoryCommand,
-  DeleteRepositoryCommand: () => DeleteRepositoryCommand,
-  DeleteRepositoryPolicyCommand: () => DeleteRepositoryPolicyCommand,
-  DescribeImageTagsCommand: () => DescribeImageTagsCommand,
-  DescribeImagesCommand: () => DescribeImagesCommand,
-  DescribeRegistriesCommand: () => DescribeRegistriesCommand,
-  DescribeRepositoriesCommand: () => DescribeRepositoriesCommand,
-  ECRPUBLIC: () => ECRPUBLIC,
-  ECRPUBLICClient: () => ECRPUBLICClient,
-  ECRPUBLICServiceException: () => ECRPUBLICServiceException,
-  EmptyUploadException: () => EmptyUploadException,
-  GetAuthorizationTokenCommand: () => GetAuthorizationTokenCommand,
-  GetRegistryCatalogDataCommand: () => GetRegistryCatalogDataCommand,
-  GetRepositoryCatalogDataCommand: () => GetRepositoryCatalogDataCommand,
-  GetRepositoryPolicyCommand: () => GetRepositoryPolicyCommand,
-  ImageAlreadyExistsException: () => ImageAlreadyExistsException,
-  ImageDigestDoesNotMatchException: () => ImageDigestDoesNotMatchException,
-  ImageFailureCode: () => ImageFailureCode,
-  ImageNotFoundException: () => ImageNotFoundException,
-  ImageTagAlreadyExistsException: () => ImageTagAlreadyExistsException,
-  InitiateLayerUploadCommand: () => InitiateLayerUploadCommand,
-  InvalidLayerException: () => InvalidLayerException,
-  InvalidLayerPartException: () => InvalidLayerPartException,
-  InvalidParameterException: () => InvalidParameterException,
-  InvalidTagParameterException: () => InvalidTagParameterException,
-  LayerAlreadyExistsException: () => LayerAlreadyExistsException,
-  LayerAvailability: () => LayerAvailability,
-  LayerFailureCode: () => LayerFailureCode,
-  LayerPartTooSmallException: () => LayerPartTooSmallException,
-  LayersNotFoundException: () => LayersNotFoundException,
-  LimitExceededException: () => LimitExceededException,
-  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
-  PutImageCommand: () => PutImageCommand,
-  PutRegistryCatalogDataCommand: () => PutRegistryCatalogDataCommand,
-  PutRepositoryCatalogDataCommand: () => PutRepositoryCatalogDataCommand,
-  ReferencedImagesNotFoundException: () => ReferencedImagesNotFoundException,
-  RegistryAliasStatus: () => RegistryAliasStatus,
-  RegistryNotFoundException: () => RegistryNotFoundException,
-  RepositoryAlreadyExistsException: () => RepositoryAlreadyExistsException,
-  RepositoryCatalogDataNotFoundException: () => RepositoryCatalogDataNotFoundException,
-  RepositoryNotEmptyException: () => RepositoryNotEmptyException,
-  RepositoryNotFoundException: () => RepositoryNotFoundException,
-  RepositoryPolicyNotFoundException: () => RepositoryPolicyNotFoundException,
-  ServerException: () => ServerException,
-  SetRepositoryPolicyCommand: () => SetRepositoryPolicyCommand,
-  TagResourceCommand: () => TagResourceCommand,
-  TooManyTagsException: () => TooManyTagsException,
-  UnsupportedCommandException: () => UnsupportedCommandException,
-  UntagResourceCommand: () => UntagResourceCommand,
-  UploadLayerPartCommand: () => UploadLayerPartCommand,
-  UploadNotFoundException: () => UploadNotFoundException,
-  __Client: () => import_smithy_client.Client,
-  paginateDescribeImageTags: () => paginateDescribeImageTags,
-  paginateDescribeImages: () => paginateDescribeImages,
-  paginateDescribeRegistries: () => paginateDescribeRegistries,
-  paginateDescribeRepositories: () => paginateDescribeRepositories
-});
-module.exports = __toCommonJS(index_exports);
-// src/ECRPUBLICClient.ts
-var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
-var import_middleware_logger = require("@aws-sdk/middleware-logger");
-var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
-var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
-var import_config_resolver = require("@smithy/config-resolver");
-var import_core = require("@smithy/core");
-var import_middleware_content_length = require("@smithy/middleware-content-length");
-var import_middleware_endpoint = require("@smithy/middleware-endpoint");
-var import_middleware_retry = require("@smithy/middleware-retry");
-var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
-// src/endpoint/EndpointParameters.ts
-var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
-  return Object.assign(options, {
-    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
-    useFipsEndpoint: options.useFipsEndpoint ?? false,
-    defaultSigningName: "ecr-public"
-  });
-}, "resolveClientEndpointParameters");
-var commonParams = {
-  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-  Endpoint: { type: "builtInParams", name: "endpoint" },
-  Region: { type: "builtInParams", name: "region" },
-  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+'use strict';
+var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
+var middlewareLogger = require('@aws-sdk/middleware-logger');
+var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
+var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
+var configResolver = require('@smithy/config-resolver');
+var core = require('@smithy/core');
+var middlewareContentLength = require('@smithy/middleware-content-length');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var middlewareRetry = require('@smithy/middleware-retry');
+var smithyClient = require('@smithy/smithy-client');
+var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
+var runtimeConfig = require('./runtimeConfig');
+var regionConfigResolver = require('@aws-sdk/region-config-resolver');
+var protocolHttp = require('@smithy/protocol-http');
+var middlewareSerde = require('@smithy/middleware-serde');
+var core$1 = require('@aws-sdk/core');
+const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "ecr-public",
+    });
+};
+const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
-// src/ECRPUBLICClient.ts
-var import_runtimeConfig = require("././runtimeConfig");
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
-// src/runtimeExtensions.ts
-var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
-var import_protocol_http = require("@smithy/protocol-http");
-var import_smithy_client = require("@smithy/smithy-client");
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
-// src/auth/httpAuthExtensionConfiguration.ts
-var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
-  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
-  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
-  let _credentials = runtimeConfig.credentials;
-  return {
-    setHttpAuthScheme(httpAuthScheme) {
-      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
-      if (index === -1) {
-        _httpAuthSchemes.push(httpAuthScheme);
-      } else {
-        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
-      }
-    },
-    httpAuthSchemes() {
-      return _httpAuthSchemes;
-    },
-    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
-      _httpAuthSchemeProvider = httpAuthSchemeProvider;
-    },
-    httpAuthSchemeProvider() {
-      return _httpAuthSchemeProvider;
-    },
-    setCredentials(credentials) {
-      _credentials = credentials;
-    },
-    credentials() {
-      return _credentials;
+class ECRPUBLICClient extends smithyClient.Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
+        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
+        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
+        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+        this.config = _config_8;
+        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
+        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
+        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultECRPUBLICHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
     }
-  };
-}, "getHttpAuthExtensionConfiguration");
-var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
-  return {
-    httpAuthSchemes: config.httpAuthSchemes(),
-    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
-    credentials: config.credentials()
-  };
-}, "resolveHttpAuthRuntimeConfig");
+    destroy() {
+        super.destroy();
+    }
+}
-// src/runtimeExtensions.ts
-var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
-  const extensionConfiguration = Object.assign(
-    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
-    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
-    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
-    getHttpAuthExtensionConfiguration(runtimeConfig)
-  );
-  extensions.forEach((extension) => extension.configure(extensionConfiguration));
-  return Object.assign(
-    runtimeConfig,
-    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
-    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
-    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
-    resolveHttpAuthRuntimeConfig(extensionConfiguration)
-  );
-}, "resolveRuntimeExtensions");
+class ECRPUBLICServiceException extends smithyClient.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, ECRPUBLICServiceException.prototype);
+    }
+}
-// src/ECRPUBLICClient.ts
-var ECRPUBLICClient = class extends import_smithy_client.Client {
-  static {
-    __name(this, "ECRPUBLICClient");
-  }
-  /**
-   * The resolved configuration of ECRPUBLICClient class. This is resolved and normalized from the {@link ECRPUBLICClientConfig | constructor configuration interface}.
-   */
-  config;
-  constructor(...[configuration]) {
-    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
-    super(_config_0);
-    this.initConfig = _config_0;
-    const _config_1 = resolveClientEndpointParameters(_config_0);
-    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
-    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
-    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
-    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
-    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
-    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
-    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
-    this.config = _config_8;
-    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
-    this.middlewareStack.use(
-      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
-        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultECRPUBLICHttpAuthSchemeParametersProvider,
-        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
-          "aws.auth#sigv4": config.credentials
-        }), "identityProviderConfigProvider")
-      })
-    );
-    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
-  }
-  /**
-   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-   */
-  destroy() {
-    super.destroy();
-  }
+const LayerFailureCode = {
+    InvalidLayerDigest: "InvalidLayerDigest",
+    MissingLayerDigest: "MissingLayerDigest",
 };
-// src/ECRPUBLIC.ts
-// src/commands/BatchCheckLayerAvailabilityCommand.ts
-var import_middleware_serde = require("@smithy/middleware-serde");
-// src/protocols/Aws_json1_1.ts
-var import_core2 = require("@aws-sdk/core");
-// src/models/ECRPUBLICServiceException.ts
-var ECRPUBLICServiceException = class _ECRPUBLICServiceException extends import_smithy_client.ServiceException {
-  static {
-    __name(this, "ECRPUBLICServiceException");
-  }
-  /**
-   * @internal
-   */
-  constructor(options) {
-    super(options);
-    Object.setPrototypeOf(this, _ECRPUBLICServiceException.prototype);
-  }
+const LayerAvailability = {
+    AVAILABLE: "AVAILABLE",
+    UNAVAILABLE: "UNAVAILABLE",
+};
+class InvalidParameterException extends ECRPUBLICServiceException {
+    name = "InvalidParameterException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidParameterException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidParameterException.prototype);
+    }
+}
+class RegistryNotFoundException extends ECRPUBLICServiceException {
+    name = "RegistryNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RegistryNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RegistryNotFoundException.prototype);
+    }
+}
+class RepositoryNotFoundException extends ECRPUBLICServiceException {
+    name = "RepositoryNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryNotFoundException.prototype);
+    }
+}
+class ServerException extends ECRPUBLICServiceException {
+    name = "ServerException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "ServerException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServerException.prototype);
+    }
+}
+class UnsupportedCommandException extends ECRPUBLICServiceException {
+    name = "UnsupportedCommandException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnsupportedCommandException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnsupportedCommandException.prototype);
+    }
+}
+const ImageFailureCode = {
+    ImageNotFound: "ImageNotFound",
+    ImageReferencedByManifestList: "ImageReferencedByManifestList",
+    ImageTagDoesNotMatchDigest: "ImageTagDoesNotMatchDigest",
+    InvalidImageDigest: "InvalidImageDigest",
+    InvalidImageTag: "InvalidImageTag",
+    KmsError: "KmsError",
+    MissingDigestAndTag: "MissingDigestAndTag",
+};
+class EmptyUploadException extends ECRPUBLICServiceException {
+    name = "EmptyUploadException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EmptyUploadException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EmptyUploadException.prototype);
+    }
+}
+class InvalidLayerException extends ECRPUBLICServiceException {
+    name = "InvalidLayerException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidLayerException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidLayerException.prototype);
+    }
+}
+class LayerAlreadyExistsException extends ECRPUBLICServiceException {
+    name = "LayerAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LayerAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LayerAlreadyExistsException.prototype);
+    }
+}
+class LayerPartTooSmallException extends ECRPUBLICServiceException {
+    name = "LayerPartTooSmallException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LayerPartTooSmallException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LayerPartTooSmallException.prototype);
+    }
+}
+class UploadNotFoundException extends ECRPUBLICServiceException {
+    name = "UploadNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UploadNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UploadNotFoundException.prototype);
+    }
+}
+class InvalidTagParameterException extends ECRPUBLICServiceException {
+    name = "InvalidTagParameterException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTagParameterException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTagParameterException.prototype);
+    }
+}
+class LimitExceededException extends ECRPUBLICServiceException {
+    name = "LimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LimitExceededException.prototype);
+    }
+}
+class RepositoryAlreadyExistsException extends ECRPUBLICServiceException {
+    name = "RepositoryAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryAlreadyExistsException.prototype);
+    }
+}
+class TooManyTagsException extends ECRPUBLICServiceException {
+    name = "TooManyTagsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TooManyTagsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TooManyTagsException.prototype);
+    }
+}
+class RepositoryNotEmptyException extends ECRPUBLICServiceException {
+    name = "RepositoryNotEmptyException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryNotEmptyException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryNotEmptyException.prototype);
+    }
+}
+class RepositoryPolicyNotFoundException extends ECRPUBLICServiceException {
+    name = "RepositoryPolicyNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryPolicyNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryPolicyNotFoundException.prototype);
+    }
+}
+class ImageNotFoundException extends ECRPUBLICServiceException {
+    name = "ImageNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ImageNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ImageNotFoundException.prototype);
+    }
+}
+const RegistryAliasStatus = {
+    ACTIVE: "ACTIVE",
+    PENDING: "PENDING",
+    REJECTED: "REJECTED",
 };
+class RepositoryCatalogDataNotFoundException extends ECRPUBLICServiceException {
+    name = "RepositoryCatalogDataNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryCatalogDataNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryCatalogDataNotFoundException.prototype);
+    }
+}
+class ImageAlreadyExistsException extends ECRPUBLICServiceException {
+    name = "ImageAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ImageAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ImageAlreadyExistsException.prototype);
+    }
+}
+class ImageDigestDoesNotMatchException extends ECRPUBLICServiceException {
+    name = "ImageDigestDoesNotMatchException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ImageDigestDoesNotMatchException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ImageDigestDoesNotMatchException.prototype);
+    }
+}
+class ImageTagAlreadyExistsException extends ECRPUBLICServiceException {
+    name = "ImageTagAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ImageTagAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ImageTagAlreadyExistsException.prototype);
+    }
+}
+class InvalidLayerPartException extends ECRPUBLICServiceException {
+    name = "InvalidLayerPartException";
+    $fault = "client";
+    registryId;
+    repositoryName;
+    uploadId;
+    lastValidByteReceived;
+    constructor(opts) {
+        super({
+            name: "InvalidLayerPartException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidLayerPartException.prototype);
+        this.registryId = opts.registryId;
+        this.repositoryName = opts.repositoryName;
+        this.uploadId = opts.uploadId;
+        this.lastValidByteReceived = opts.lastValidByteReceived;
+    }
+}
+class LayersNotFoundException extends ECRPUBLICServiceException {
+    name = "LayersNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LayersNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LayersNotFoundException.prototype);
+    }
+}
+class ReferencedImagesNotFoundException extends ECRPUBLICServiceException {
+    name = "ReferencedImagesNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReferencedImagesNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReferencedImagesNotFoundException.prototype);
+    }
+}
-// src/models/models_0.ts
-var LayerFailureCode = {
-  InvalidLayerDigest: "InvalidLayerDigest",
-  MissingLayerDigest: "MissingLayerDigest"
-};
-var LayerAvailability = {
-  AVAILABLE: "AVAILABLE",
-  UNAVAILABLE: "UNAVAILABLE"
-};
-var InvalidParameterException = class _InvalidParameterException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "InvalidParameterException");
-  }
-  name = "InvalidParameterException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidParameterException",
-      $fault: "client",
-      ...opts
+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,
     });
-    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
-  }
-};
-var RegistryNotFoundException = class _RegistryNotFoundException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "RegistryNotFoundException");
-  }
-  name = "RegistryNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RegistryNotFoundException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _RegistryNotFoundException.prototype);
-  }
-};
-var RepositoryNotFoundException = class _RepositoryNotFoundException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "RepositoryNotFoundException");
-  }
-  name = "RepositoryNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RepositoryNotFoundException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _RepositoryNotFoundException.prototype);
-  }
-};
-var ServerException = class _ServerException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "ServerException");
-  }
-  name = "ServerException";
-  $fault = "server";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ServerException",
-      $fault: "server",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _ServerException.prototype);
-  }
-};
-var UnsupportedCommandException = class _UnsupportedCommandException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "UnsupportedCommandException");
-  }
-  name = "UnsupportedCommandException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "UnsupportedCommandException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _UnsupportedCommandException.prototype);
-  }
-};
-var ImageFailureCode = {
-  ImageNotFound: "ImageNotFound",
-  ImageReferencedByManifestList: "ImageReferencedByManifestList",
-  ImageTagDoesNotMatchDigest: "ImageTagDoesNotMatchDigest",
-  InvalidImageDigest: "InvalidImageDigest",
-  InvalidImageTag: "InvalidImageTag",
-  KmsError: "KmsError",
-  MissingDigestAndTag: "MissingDigestAndTag"
-};
-var EmptyUploadException = class _EmptyUploadException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "EmptyUploadException");
-  }
-  name = "EmptyUploadException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "EmptyUploadException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _EmptyUploadException.prototype);
-  }
-};
-var InvalidLayerException = class _InvalidLayerException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "InvalidLayerException");
-  }
-  name = "InvalidLayerException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidLayerException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _InvalidLayerException.prototype);
-  }
-};
-var LayerAlreadyExistsException = class _LayerAlreadyExistsException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "LayerAlreadyExistsException");
-  }
-  name = "LayerAlreadyExistsException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LayerAlreadyExistsException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _LayerAlreadyExistsException.prototype);
-  }
-};
-var LayerPartTooSmallException = class _LayerPartTooSmallException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "LayerPartTooSmallException");
-  }
-  name = "LayerPartTooSmallException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LayerPartTooSmallException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _LayerPartTooSmallException.prototype);
-  }
-};
-var UploadNotFoundException = class _UploadNotFoundException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "UploadNotFoundException");
-  }
-  name = "UploadNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "UploadNotFoundException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _UploadNotFoundException.prototype);
-  }
-};
-var InvalidTagParameterException = class _InvalidTagParameterException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "InvalidTagParameterException");
-  }
-  name = "InvalidTagParameterException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidTagParameterException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _InvalidTagParameterException.prototype);
-  }
-};
-var LimitExceededException = class _LimitExceededException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "LimitExceededException");
-  }
-  name = "LimitExceededException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LimitExceededException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _LimitExceededException.prototype);
-  }
-};
-var RepositoryAlreadyExistsException = class _RepositoryAlreadyExistsException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "RepositoryAlreadyExistsException");
-  }
-  name = "RepositoryAlreadyExistsException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RepositoryAlreadyExistsException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _RepositoryAlreadyExistsException.prototype);
-  }
-};
-var TooManyTagsException = class _TooManyTagsException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "TooManyTagsException");
-  }
-  name = "TooManyTagsException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TooManyTagsException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
-  }
-};
-var RepositoryNotEmptyException = class _RepositoryNotEmptyException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "RepositoryNotEmptyException");
-  }
-  name = "RepositoryNotEmptyException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RepositoryNotEmptyException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _RepositoryNotEmptyException.prototype);
-  }
-};
-var RepositoryPolicyNotFoundException = class _RepositoryPolicyNotFoundException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "RepositoryPolicyNotFoundException");
-  }
-  name = "RepositoryPolicyNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RepositoryPolicyNotFoundException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _RepositoryPolicyNotFoundException.prototype);
-  }
-};
-var ImageNotFoundException = class _ImageNotFoundException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "ImageNotFoundException");
-  }
-  name = "ImageNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ImageNotFoundException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _ImageNotFoundException.prototype);
-  }
-};
-var RegistryAliasStatus = {
-  ACTIVE: "ACTIVE",
-  PENDING: "PENDING",
-  REJECTED: "REJECTED"
-};
-var RepositoryCatalogDataNotFoundException = class _RepositoryCatalogDataNotFoundException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "RepositoryCatalogDataNotFoundException");
-  }
-  name = "RepositoryCatalogDataNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RepositoryCatalogDataNotFoundException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _RepositoryCatalogDataNotFoundException.prototype);
-  }
-};
-var ImageAlreadyExistsException = class _ImageAlreadyExistsException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "ImageAlreadyExistsException");
-  }
-  name = "ImageAlreadyExistsException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ImageAlreadyExistsException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _ImageAlreadyExistsException.prototype);
-  }
-};
-var ImageDigestDoesNotMatchException = class _ImageDigestDoesNotMatchException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "ImageDigestDoesNotMatchException");
-  }
-  name = "ImageDigestDoesNotMatchException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ImageDigestDoesNotMatchException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _ImageDigestDoesNotMatchException.prototype);
-  }
-};
-var ImageTagAlreadyExistsException = class _ImageTagAlreadyExistsException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "ImageTagAlreadyExistsException");
-  }
-  name = "ImageTagAlreadyExistsException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ImageTagAlreadyExistsException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _ImageTagAlreadyExistsException.prototype);
-  }
-};
-var InvalidLayerPartException = class _InvalidLayerPartException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "InvalidLayerPartException");
-  }
-  name = "InvalidLayerPartException";
-  $fault = "client";
-  /**
-   * <p>The Amazon Web Services account ID that's associated with the layer part.</p>
-   * @public
-   */
-  registryId;
-  /**
-   * <p>The name of the repository.</p>
-   * @public
-   */
-  repositoryName;
-  /**
-   * <p>The upload ID that's associated with the layer part.</p>
-   * @public
-   */
-  uploadId;
-  /**
-   * <p>The position of the last byte of the layer part.</p>
-   * @public
-   */
-  lastValidByteReceived;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidLayerPartException",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _InvalidLayerPartException.prototype);
-    this.registryId = opts.registryId;
-    this.repositoryName = opts.repositoryName;
-    this.uploadId = opts.uploadId;
-    this.lastValidByteReceived = opts.lastValidByteReceived;
-  }
-};
-var LayersNotFoundException = class _LayersNotFoundException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "LayersNotFoundException");
-  }
-  name = "LayersNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LayersNotFoundException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const se_CreateRepositoryRequest = (input, context) => {
+    return smithyClient.take(input, {
+        catalogData: (_) => se_RepositoryCatalogDataInput(_, context),
+        repositoryName: [],
+        tags: smithyClient._json,
     });
-    Object.setPrototypeOf(this, _LayersNotFoundException.prototype);
-  }
-};
-var ReferencedImagesNotFoundException = class _ReferencedImagesNotFoundException extends ECRPUBLICServiceException {
-  static {
-    __name(this, "ReferencedImagesNotFoundException");
-  }
-  name = "ReferencedImagesNotFoundException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ReferencedImagesNotFoundException",
-      $fault: "client",
-      ...opts
+};
+const se_PutRepositoryCatalogDataRequest = (input, context) => {
+    return smithyClient.take(input, {
+        catalogData: (_) => se_RepositoryCatalogDataInput(_, context),
+        registryId: [],
+        repositoryName: [],
     });
-    Object.setPrototypeOf(this, _ReferencedImagesNotFoundException.prototype);
-  }
 };
-// src/protocols/Aws_json1_1.ts
-var se_BatchCheckLayerAvailabilityCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("BatchCheckLayerAvailability");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_BatchCheckLayerAvailabilityCommand");
-var se_BatchDeleteImageCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("BatchDeleteImage");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_BatchDeleteImageCommand");
-var se_CompleteLayerUploadCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("CompleteLayerUpload");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_CompleteLayerUploadCommand");
-var se_CreateRepositoryCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("CreateRepository");
-  let body;
-  body = JSON.stringify(se_CreateRepositoryRequest(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_CreateRepositoryCommand");
-var se_DeleteRepositoryCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DeleteRepository");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DeleteRepositoryCommand");
-var se_DeleteRepositoryPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DeleteRepositoryPolicy");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DeleteRepositoryPolicyCommand");
-var se_DescribeImagesCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DescribeImages");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DescribeImagesCommand");
-var se_DescribeImageTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DescribeImageTags");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DescribeImageTagsCommand");
-var se_DescribeRegistriesCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DescribeRegistries");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DescribeRegistriesCommand");
-var se_DescribeRepositoriesCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DescribeRepositories");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DescribeRepositoriesCommand");
-var se_GetAuthorizationTokenCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("GetAuthorizationToken");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_GetAuthorizationTokenCommand");
-var se_GetRegistryCatalogDataCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("GetRegistryCatalogData");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_GetRegistryCatalogDataCommand");
-var se_GetRepositoryCatalogDataCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("GetRepositoryCatalogData");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_GetRepositoryCatalogDataCommand");
-var se_GetRepositoryPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("GetRepositoryPolicy");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_GetRepositoryPolicyCommand");
-var se_InitiateLayerUploadCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("InitiateLayerUpload");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_InitiateLayerUploadCommand");
-var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListTagsForResource");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListTagsForResourceCommand");
-var se_PutImageCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("PutImage");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_PutImageCommand");
-var se_PutRegistryCatalogDataCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("PutRegistryCatalogData");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_PutRegistryCatalogDataCommand");
-var se_PutRepositoryCatalogDataCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("PutRepositoryCatalogData");
-  let body;
-  body = JSON.stringify(se_PutRepositoryCatalogDataRequest(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_PutRepositoryCatalogDataCommand");
-var se_SetRepositoryPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("SetRepositoryPolicy");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_SetRepositoryPolicyCommand");
-var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("TagResource");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_TagResourceCommand");
-var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("UntagResource");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_UntagResourceCommand");
-var se_UploadLayerPartCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("UploadLayerPart");
-  let body;
-  body = JSON.stringify(se_UploadLayerPartRequest(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_UploadLayerPartCommand");
-var de_BatchCheckLayerAvailabilityCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_BatchCheckLayerAvailabilityCommand");
-var de_BatchDeleteImageCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_BatchDeleteImageCommand");
-var de_CompleteLayerUploadCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CompleteLayerUploadCommand");
-var de_CreateRepositoryCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_CreateRepositoryResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateRepositoryCommand");
-var de_DeleteRepositoryCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DeleteRepositoryResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteRepositoryCommand");
-var de_DeleteRepositoryPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteRepositoryPolicyCommand");
-var de_DescribeImagesCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DescribeImagesResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeImagesCommand");
-var de_DescribeImageTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DescribeImageTagsResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeImageTagsCommand");
-var de_DescribeRegistriesCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeRegistriesCommand");
-var de_DescribeRepositoriesCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DescribeRepositoriesResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeRepositoriesCommand");
-var de_GetAuthorizationTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_GetAuthorizationTokenResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetAuthorizationTokenCommand");
-var de_GetRegistryCatalogDataCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetRegistryCatalogDataCommand");
-var de_GetRepositoryCatalogDataCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetRepositoryCatalogDataCommand");
-var de_GetRepositoryPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetRepositoryPolicyCommand");
-var de_InitiateLayerUploadCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_InitiateLayerUploadCommand");
-var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListTagsForResourceCommand");
-var de_PutImageCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_PutImageCommand");
-var de_PutRegistryCatalogDataCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_PutRegistryCatalogDataCommand");
-var de_PutRepositoryCatalogDataCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_PutRepositoryCatalogDataCommand");
-var de_SetRepositoryPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_SetRepositoryPolicyCommand");
-var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_TagResourceCommand");
-var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UntagResourceCommand");
-var de_UploadLayerPartCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UploadLayerPartCommand");
-var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
-  const parsedOutput = {
-    ...output,
-    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
-  };
-  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
-  switch (errorCode) {
-    case "InvalidParameterException":
-    case "com.amazonaws.ecrpublic#InvalidParameterException":
-      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
-    case "RegistryNotFoundException":
-    case "com.amazonaws.ecrpublic#RegistryNotFoundException":
-      throw await de_RegistryNotFoundExceptionRes(parsedOutput, context);
-    case "RepositoryNotFoundException":
-    case "com.amazonaws.ecrpublic#RepositoryNotFoundException":
-      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
-    case "ServerException":
-    case "com.amazonaws.ecrpublic#ServerException":
-      throw await de_ServerExceptionRes(parsedOutput, context);
-    case "UnsupportedCommandException":
-    case "com.amazonaws.ecrpublic#UnsupportedCommandException":
-      throw await de_UnsupportedCommandExceptionRes(parsedOutput, context);
-    case "EmptyUploadException":
-    case "com.amazonaws.ecrpublic#EmptyUploadException":
-      throw await de_EmptyUploadExceptionRes(parsedOutput, context);
-    case "InvalidLayerException":
-    case "com.amazonaws.ecrpublic#InvalidLayerException":
-      throw await de_InvalidLayerExceptionRes(parsedOutput, context);
-    case "LayerAlreadyExistsException":
-    case "com.amazonaws.ecrpublic#LayerAlreadyExistsException":
-      throw await de_LayerAlreadyExistsExceptionRes(parsedOutput, context);
-    case "LayerPartTooSmallException":
-    case "com.amazonaws.ecrpublic#LayerPartTooSmallException":
-      throw await de_LayerPartTooSmallExceptionRes(parsedOutput, context);
-    case "UploadNotFoundException":
-    case "com.amazonaws.ecrpublic#UploadNotFoundException":
-      throw await de_UploadNotFoundExceptionRes(parsedOutput, context);
-    case "InvalidTagParameterException":
-    case "com.amazonaws.ecrpublic#InvalidTagParameterException":
-      throw await de_InvalidTagParameterExceptionRes(parsedOutput, context);
-    case "LimitExceededException":
-    case "com.amazonaws.ecrpublic#LimitExceededException":
-      throw await de_LimitExceededExceptionRes(parsedOutput, context);
-    case "RepositoryAlreadyExistsException":
-    case "com.amazonaws.ecrpublic#RepositoryAlreadyExistsException":
-      throw await de_RepositoryAlreadyExistsExceptionRes(parsedOutput, context);
-    case "TooManyTagsException":
-    case "com.amazonaws.ecrpublic#TooManyTagsException":
-      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
-    case "RepositoryNotEmptyException":
-    case "com.amazonaws.ecrpublic#RepositoryNotEmptyException":
-      throw await de_RepositoryNotEmptyExceptionRes(parsedOutput, context);
-    case "RepositoryPolicyNotFoundException":
-    case "com.amazonaws.ecrpublic#RepositoryPolicyNotFoundException":
-      throw await de_RepositoryPolicyNotFoundExceptionRes(parsedOutput, context);
-    case "ImageNotFoundException":
-    case "com.amazonaws.ecrpublic#ImageNotFoundException":
-      throw await de_ImageNotFoundExceptionRes(parsedOutput, context);
-    case "RepositoryCatalogDataNotFoundException":
-    case "com.amazonaws.ecrpublic#RepositoryCatalogDataNotFoundException":
-      throw await de_RepositoryCatalogDataNotFoundExceptionRes(parsedOutput, context);
-    case "ImageAlreadyExistsException":
-    case "com.amazonaws.ecrpublic#ImageAlreadyExistsException":
-      throw await de_ImageAlreadyExistsExceptionRes(parsedOutput, context);
-    case "ImageDigestDoesNotMatchException":
-    case "com.amazonaws.ecrpublic#ImageDigestDoesNotMatchException":
-      throw await de_ImageDigestDoesNotMatchExceptionRes(parsedOutput, context);
-    case "ImageTagAlreadyExistsException":
-    case "com.amazonaws.ecrpublic#ImageTagAlreadyExistsException":
-      throw await de_ImageTagAlreadyExistsExceptionRes(parsedOutput, context);
-    case "LayersNotFoundException":
-    case "com.amazonaws.ecrpublic#LayersNotFoundException":
-      throw await de_LayersNotFoundExceptionRes(parsedOutput, context);
-    case "ReferencedImagesNotFoundException":
-    case "com.amazonaws.ecrpublic#ReferencedImagesNotFoundException":
-      throw await de_ReferencedImagesNotFoundExceptionRes(parsedOutput, context);
-    case "InvalidLayerPartException":
-    case "com.amazonaws.ecrpublic#InvalidLayerPartException":
-      throw await de_InvalidLayerPartExceptionRes(parsedOutput, context);
-    default:
-      const parsedBody = parsedOutput.body;
-      return throwDefaultError({
-        output,
-        parsedBody,
-        errorCode
-      });
-  }
-}, "de_CommandError");
-var de_EmptyUploadExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new EmptyUploadException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_EmptyUploadExceptionRes");
-var de_ImageAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ImageAlreadyExistsException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ImageAlreadyExistsExceptionRes");
-var de_ImageDigestDoesNotMatchExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ImageDigestDoesNotMatchException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ImageDigestDoesNotMatchExceptionRes");
-var de_ImageNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ImageNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ImageNotFoundExceptionRes");
-var de_ImageTagAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ImageTagAlreadyExistsException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ImageTagAlreadyExistsExceptionRes");
-var de_InvalidLayerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new InvalidLayerException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_InvalidLayerExceptionRes");
-var de_InvalidLayerPartExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new InvalidLayerPartException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_InvalidLayerPartExceptionRes");
-var de_InvalidParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new InvalidParameterException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_InvalidParameterExceptionRes");
-var de_InvalidTagParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new InvalidTagParameterException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_InvalidTagParameterExceptionRes");
-var de_LayerAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new LayerAlreadyExistsException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_LayerAlreadyExistsExceptionRes");
-var de_LayerPartTooSmallExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new LayerPartTooSmallException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_LayerPartTooSmallExceptionRes");
-var de_LayersNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new LayersNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_LayersNotFoundExceptionRes");
-var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new LimitExceededException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_LimitExceededExceptionRes");
-var de_ReferencedImagesNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ReferencedImagesNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ReferencedImagesNotFoundExceptionRes");
-var de_RegistryNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new RegistryNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_RegistryNotFoundExceptionRes");
-var de_RepositoryAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new RepositoryAlreadyExistsException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_RepositoryAlreadyExistsExceptionRes");
-var de_RepositoryCatalogDataNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new RepositoryCatalogDataNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_RepositoryCatalogDataNotFoundExceptionRes");
-var de_RepositoryNotEmptyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new RepositoryNotEmptyException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_RepositoryNotEmptyExceptionRes");
-var de_RepositoryNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new RepositoryNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_RepositoryNotFoundExceptionRes");
-var de_RepositoryPolicyNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new RepositoryPolicyNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_RepositoryPolicyNotFoundExceptionRes");
-var de_ServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ServerException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ServerExceptionRes");
-var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new TooManyTagsException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_TooManyTagsExceptionRes");
-var de_UnsupportedCommandExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new UnsupportedCommandException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_UnsupportedCommandExceptionRes");
-var de_UploadNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new UploadNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_UploadNotFoundExceptionRes");
-var se_CreateRepositoryRequest = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    catalogData: /* @__PURE__ */ __name((_) => se_RepositoryCatalogDataInput(_, context), "catalogData"),
-    repositoryName: [],
-    tags: import_smithy_client._json
-  });
-}, "se_CreateRepositoryRequest");
-var se_PutRepositoryCatalogDataRequest = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    catalogData: /* @__PURE__ */ __name((_) => se_RepositoryCatalogDataInput(_, context), "catalogData"),
-    registryId: [],
-    repositoryName: []
-  });
-}, "se_PutRepositoryCatalogDataRequest");
-var se_RepositoryCatalogDataInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    aboutText: [],
-    architectures: import_smithy_client._json,
-    description: [],
-    logoImageBlob: context.base64Encoder,
-    operatingSystems: import_smithy_client._json,
-    usageText: []
-  });
-}, "se_RepositoryCatalogDataInput");
-var se_UploadLayerPartRequest = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    layerPartBlob: context.base64Encoder,
-    partFirstByte: [],
-    partLastByte: [],
-    registryId: [],
-    repositoryName: [],
-    uploadId: []
-  });
-}, "se_UploadLayerPartRequest");
-var de_AuthorizationData = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    authorizationToken: import_smithy_client.expectString,
-    expiresAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "expiresAt")
-  });
-}, "de_AuthorizationData");
-var de_CreateRepositoryResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    catalogData: import_smithy_client._json,
-    repository: /* @__PURE__ */ __name((_) => de_Repository(_, context), "repository")
-  });
-}, "de_CreateRepositoryResponse");
-var de_DeleteRepositoryResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    repository: /* @__PURE__ */ __name((_) => de_Repository(_, context), "repository")
-  });
-}, "de_DeleteRepositoryResponse");
-var de_DescribeImagesResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    imageDetails: /* @__PURE__ */ __name((_) => de_ImageDetailList(_, context), "imageDetails"),
-    nextToken: import_smithy_client.expectString
-  });
-}, "de_DescribeImagesResponse");
-var de_DescribeImageTagsResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    imageTagDetails: /* @__PURE__ */ __name((_) => de_ImageTagDetailList(_, context), "imageTagDetails"),
-    nextToken: import_smithy_client.expectString
-  });
-}, "de_DescribeImageTagsResponse");
-var de_DescribeRepositoriesResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    nextToken: import_smithy_client.expectString,
-    repositories: /* @__PURE__ */ __name((_) => de_RepositoryList(_, context), "repositories")
-  });
-}, "de_DescribeRepositoriesResponse");
-var de_GetAuthorizationTokenResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    authorizationData: /* @__PURE__ */ __name((_) => de_AuthorizationData(_, context), "authorizationData")
-  });
-}, "de_GetAuthorizationTokenResponse");
-var de_ImageDetail = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    artifactMediaType: import_smithy_client.expectString,
-    imageDigest: import_smithy_client.expectString,
-    imageManifestMediaType: import_smithy_client.expectString,
-    imagePushedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "imagePushedAt"),
-    imageSizeInBytes: import_smithy_client.expectLong,
-    imageTags: import_smithy_client._json,
-    registryId: import_smithy_client.expectString,
-    repositoryName: import_smithy_client.expectString
-  });
-}, "de_ImageDetail");
-var de_ImageDetailList = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_ImageDetail(entry, context);
-  });
-  return retVal;
-}, "de_ImageDetailList");
-var de_ImageTagDetail = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
-    imageDetail: /* @__PURE__ */ __name((_) => de_ReferencedImageDetail(_, context), "imageDetail"),
-    imageTag: import_smithy_client.expectString
-  });
-}, "de_ImageTagDetail");
-var de_ImageTagDetailList = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_ImageTagDetail(entry, context);
-  });
-  return retVal;
-}, "de_ImageTagDetailList");
-var de_ReferencedImageDetail = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    artifactMediaType: import_smithy_client.expectString,
-    imageDigest: import_smithy_client.expectString,
-    imageManifestMediaType: import_smithy_client.expectString,
-    imagePushedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "imagePushedAt"),
-    imageSizeInBytes: import_smithy_client.expectLong
-  });
-}, "de_ReferencedImageDetail");
-var de_Repository = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "createdAt"),
-    registryId: import_smithy_client.expectString,
-    repositoryArn: import_smithy_client.expectString,
-    repositoryName: import_smithy_client.expectString,
-    repositoryUri: import_smithy_client.expectString
-  });
-}, "de_Repository");
-var de_RepositoryList = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_Repository(entry, context);
-  });
-  return retVal;
-}, "de_RepositoryList");
-var deserializeMetadata = /* @__PURE__ */ __name((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"]
-}), "deserializeMetadata");
-var throwDefaultError = (0, import_smithy_client.withBaseException)(ECRPUBLICServiceException);
-var buildHttpRpcRequest = /* @__PURE__ */ __name(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 (resolvedHostname !== void 0) {
-    contents.hostname = resolvedHostname;
-  }
-  if (body !== void 0) {
-    contents.body = body;
-  }
-  return new import_protocol_http.HttpRequest(contents);
-}, "buildHttpRpcRequest");
-function sharedHeaders(operation) {
-  return {
-    "content-type": "application/x-amz-json-1.1",
-    "x-amz-target": `SpencerFrontendService.${operation}`
-  };
-}
-__name(sharedHeaders, "sharedHeaders");
-// src/commands/BatchCheckLayerAvailabilityCommand.ts
-var BatchCheckLayerAvailabilityCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "BatchCheckLayerAvailability", {}).n("ECRPUBLICClient", "BatchCheckLayerAvailabilityCommand").f(void 0, void 0).ser(se_BatchCheckLayerAvailabilityCommand).de(de_BatchCheckLayerAvailabilityCommand).build() {
-  static {
-    __name(this, "BatchCheckLayerAvailabilityCommand");
-  }
+const se_RepositoryCatalogDataInput = (input, context) => {
+    return smithyClient.take(input, {
+        aboutText: [],
+        architectures: smithyClient._json,
+        description: [],
+        logoImageBlob: context.base64Encoder,
+        operatingSystems: smithyClient._json,
+        usageText: [],
+    });
 };
-// src/commands/BatchDeleteImageCommand.ts
-var BatchDeleteImageCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "BatchDeleteImage", {}).n("ECRPUBLICClient", "BatchDeleteImageCommand").f(void 0, void 0).ser(se_BatchDeleteImageCommand).de(de_BatchDeleteImageCommand).build() {
-  static {
-    __name(this, "BatchDeleteImageCommand");
-  }
+const se_UploadLayerPartRequest = (input, context) => {
+    return smithyClient.take(input, {
+        layerPartBlob: context.base64Encoder,
+        partFirstByte: [],
+        partLastByte: [],
+        registryId: [],
+        repositoryName: [],
+        uploadId: [],
+    });
 };
-// src/commands/CompleteLayerUploadCommand.ts
-var CompleteLayerUploadCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "CompleteLayerUpload", {}).n("ECRPUBLICClient", "CompleteLayerUploadCommand").f(void 0, void 0).ser(se_CompleteLayerUploadCommand).de(de_CompleteLayerUploadCommand).build() {
-  static {
-    __name(this, "CompleteLayerUploadCommand");
-  }
+const de_AuthorizationData = (output, context) => {
+    return smithyClient.take(output, {
+        authorizationToken: smithyClient.expectString,
+        expiresAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+    });
 };
-// src/commands/CreateRepositoryCommand.ts
-var CreateRepositoryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "CreateRepository", {}).n("ECRPUBLICClient", "CreateRepositoryCommand").f(void 0, void 0).ser(se_CreateRepositoryCommand).de(de_CreateRepositoryCommand).build() {
-  static {
-    __name(this, "CreateRepositoryCommand");
-  }
+const de_CreateRepositoryResponse = (output, context) => {
+    return smithyClient.take(output, {
+        catalogData: smithyClient._json,
+        repository: (_) => de_Repository(_),
+    });
 };
-// src/commands/DeleteRepositoryCommand.ts
-var DeleteRepositoryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "DeleteRepository", {}).n("ECRPUBLICClient", "DeleteRepositoryCommand").f(void 0, void 0).ser(se_DeleteRepositoryCommand).de(de_DeleteRepositoryCommand).build() {
-  static {
-    __name(this, "DeleteRepositoryCommand");
-  }
+const de_DeleteRepositoryResponse = (output, context) => {
+    return smithyClient.take(output, {
+        repository: (_) => de_Repository(_),
+    });
 };
-// src/commands/DeleteRepositoryPolicyCommand.ts
-var DeleteRepositoryPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "DeleteRepositoryPolicy", {}).n("ECRPUBLICClient", "DeleteRepositoryPolicyCommand").f(void 0, void 0).ser(se_DeleteRepositoryPolicyCommand).de(de_DeleteRepositoryPolicyCommand).build() {
-  static {
-    __name(this, "DeleteRepositoryPolicyCommand");
-  }
+const de_DescribeImagesResponse = (output, context) => {
+    return smithyClient.take(output, {
+        imageDetails: (_) => de_ImageDetailList(_),
+        nextToken: smithyClient.expectString,
+    });
 };
-// src/commands/DescribeImagesCommand.ts
-var DescribeImagesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "DescribeImages", {}).n("ECRPUBLICClient", "DescribeImagesCommand").f(void 0, void 0).ser(se_DescribeImagesCommand).de(de_DescribeImagesCommand).build() {
-  static {
-    __name(this, "DescribeImagesCommand");
-  }
+const de_DescribeImageTagsResponse = (output, context) => {
+    return smithyClient.take(output, {
+        imageTagDetails: (_) => de_ImageTagDetailList(_),
+        nextToken: smithyClient.expectString,
+    });
 };
-// src/commands/DescribeImageTagsCommand.ts
-var DescribeImageTagsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "DescribeImageTags", {}).n("ECRPUBLICClient", "DescribeImageTagsCommand").f(void 0, void 0).ser(se_DescribeImageTagsCommand).de(de_DescribeImageTagsCommand).build() {
-  static {
-    __name(this, "DescribeImageTagsCommand");
-  }
+const de_DescribeRepositoriesResponse = (output, context) => {
+    return smithyClient.take(output, {
+        nextToken: smithyClient.expectString,
+        repositories: (_) => de_RepositoryList(_),
+    });
 };
-// src/commands/DescribeRegistriesCommand.ts
-var DescribeRegistriesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "DescribeRegistries", {}).n("ECRPUBLICClient", "DescribeRegistriesCommand").f(void 0, void 0).ser(se_DescribeRegistriesCommand).de(de_DescribeRegistriesCommand).build() {
-  static {
-    __name(this, "DescribeRegistriesCommand");
-  }
+const de_GetAuthorizationTokenResponse = (output, context) => {
+    return smithyClient.take(output, {
+        authorizationData: (_) => de_AuthorizationData(_),
+    });
 };
-// src/commands/DescribeRepositoriesCommand.ts
-var DescribeRepositoriesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "DescribeRepositories", {}).n("ECRPUBLICClient", "DescribeRepositoriesCommand").f(void 0, void 0).ser(se_DescribeRepositoriesCommand).de(de_DescribeRepositoriesCommand).build() {
-  static {
-    __name(this, "DescribeRepositoriesCommand");
-  }
+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,
+    });
 };
-// src/commands/GetAuthorizationTokenCommand.ts
-var GetAuthorizationTokenCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "GetAuthorizationToken", {}).n("ECRPUBLICClient", "GetAuthorizationTokenCommand").f(void 0, void 0).ser(se_GetAuthorizationTokenCommand).de(de_GetAuthorizationTokenCommand).build() {
-  static {
-    __name(this, "GetAuthorizationTokenCommand");
-  }
+const de_ImageDetailList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ImageDetail(entry);
+    });
+    return retVal;
 };
-// src/commands/GetRegistryCatalogDataCommand.ts
-var GetRegistryCatalogDataCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "GetRegistryCatalogData", {}).n("ECRPUBLICClient", "GetRegistryCatalogDataCommand").f(void 0, void 0).ser(se_GetRegistryCatalogDataCommand).de(de_GetRegistryCatalogDataCommand).build() {
-  static {
-    __name(this, "GetRegistryCatalogDataCommand");
-  }
+const de_ImageTagDetail = (output, context) => {
+    return smithyClient.take(output, {
+        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        imageDetail: (_) => de_ReferencedImageDetail(_),
+        imageTag: smithyClient.expectString,
+    });
 };
-// src/commands/GetRepositoryCatalogDataCommand.ts
-var GetRepositoryCatalogDataCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "GetRepositoryCatalogData", {}).n("ECRPUBLICClient", "GetRepositoryCatalogDataCommand").f(void 0, void 0).ser(se_GetRepositoryCatalogDataCommand).de(de_GetRepositoryCatalogDataCommand).build() {
-  static {
-    __name(this, "GetRepositoryCatalogDataCommand");
-  }
+const de_ImageTagDetailList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ImageTagDetail(entry);
+    });
+    return retVal;
 };
-// src/commands/GetRepositoryPolicyCommand.ts
-var GetRepositoryPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "GetRepositoryPolicy", {}).n("ECRPUBLICClient", "GetRepositoryPolicyCommand").f(void 0, void 0).ser(se_GetRepositoryPolicyCommand).de(de_GetRepositoryPolicyCommand).build() {
-  static {
-    __name(this, "GetRepositoryPolicyCommand");
-  }
+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,
+    });
 };
-// src/commands/InitiateLayerUploadCommand.ts
-var InitiateLayerUploadCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "InitiateLayerUpload", {}).n("ECRPUBLICClient", "InitiateLayerUploadCommand").f(void 0, void 0).ser(se_InitiateLayerUploadCommand).de(de_InitiateLayerUploadCommand).build() {
-  static {
-    __name(this, "InitiateLayerUploadCommand");
-  }
+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,
+    });
 };
-// src/commands/ListTagsForResourceCommand.ts
-var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "ListTagsForResource", {}).n("ECRPUBLICClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
-  static {
-    __name(this, "ListTagsForResourceCommand");
-  }
+const de_RepositoryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Repository(entry);
+    });
+    return retVal;
 };
-// src/commands/PutImageCommand.ts
-var PutImageCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "PutImage", {}).n("ECRPUBLICClient", "PutImageCommand").f(void 0, void 0).ser(se_PutImageCommand).de(de_PutImageCommand).build() {
-  static {
-    __name(this, "PutImageCommand");
-  }
+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}`,
+    };
+}
-// src/commands/PutRegistryCatalogDataCommand.ts
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "BatchCheckLayerAvailability", {})
+    .n("ECRPUBLICClient", "BatchCheckLayerAvailabilityCommand")
+    .f(void 0, void 0)
+    .ser(se_BatchCheckLayerAvailabilityCommand)
+    .de(de_BatchCheckLayerAvailabilityCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "BatchDeleteImage", {})
+    .n("ECRPUBLICClient", "BatchDeleteImageCommand")
+    .f(void 0, void 0)
+    .ser(se_BatchDeleteImageCommand)
+    .de(de_BatchDeleteImageCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "CompleteLayerUpload", {})
+    .n("ECRPUBLICClient", "CompleteLayerUploadCommand")
+    .f(void 0, void 0)
+    .ser(se_CompleteLayerUploadCommand)
+    .de(de_CompleteLayerUploadCommand)
+    .build() {
+}
-var PutRegistryCatalogDataCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "PutRegistryCatalogData", {}).n("ECRPUBLICClient", "PutRegistryCatalogDataCommand").f(void 0, void 0).ser(se_PutRegistryCatalogDataCommand).de(de_PutRegistryCatalogDataCommand).build() {
-  static {
-    __name(this, "PutRegistryCatalogDataCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "CreateRepository", {})
+    .n("ECRPUBLICClient", "CreateRepositoryCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateRepositoryCommand)
+    .de(de_CreateRepositoryCommand)
+    .build() {
+}
-// src/commands/PutRepositoryCatalogDataCommand.ts
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "DeleteRepository", {})
+    .n("ECRPUBLICClient", "DeleteRepositoryCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteRepositoryCommand)
+    .de(de_DeleteRepositoryCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "DeleteRepositoryPolicy", {})
+    .n("ECRPUBLICClient", "DeleteRepositoryPolicyCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteRepositoryPolicyCommand)
+    .de(de_DeleteRepositoryPolicyCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "DescribeImages", {})
+    .n("ECRPUBLICClient", "DescribeImagesCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeImagesCommand)
+    .de(de_DescribeImagesCommand)
+    .build() {
+}
-var PutRepositoryCatalogDataCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "PutRepositoryCatalogData", {}).n("ECRPUBLICClient", "PutRepositoryCatalogDataCommand").f(void 0, void 0).ser(se_PutRepositoryCatalogDataCommand).de(de_PutRepositoryCatalogDataCommand).build() {
-  static {
-    __name(this, "PutRepositoryCatalogDataCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "DescribeImageTags", {})
+    .n("ECRPUBLICClient", "DescribeImageTagsCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeImageTagsCommand)
+    .de(de_DescribeImageTagsCommand)
+    .build() {
+}
-// src/commands/SetRepositoryPolicyCommand.ts
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "DescribeRegistries", {})
+    .n("ECRPUBLICClient", "DescribeRegistriesCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeRegistriesCommand)
+    .de(de_DescribeRegistriesCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "DescribeRepositories", {})
+    .n("ECRPUBLICClient", "DescribeRepositoriesCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeRepositoriesCommand)
+    .de(de_DescribeRepositoriesCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "GetAuthorizationToken", {})
+    .n("ECRPUBLICClient", "GetAuthorizationTokenCommand")
+    .f(void 0, void 0)
+    .ser(se_GetAuthorizationTokenCommand)
+    .de(de_GetAuthorizationTokenCommand)
+    .build() {
+}
-var SetRepositoryPolicyCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "SetRepositoryPolicy", {}).n("ECRPUBLICClient", "SetRepositoryPolicyCommand").f(void 0, void 0).ser(se_SetRepositoryPolicyCommand).de(de_SetRepositoryPolicyCommand).build() {
-  static {
-    __name(this, "SetRepositoryPolicyCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "GetRegistryCatalogData", {})
+    .n("ECRPUBLICClient", "GetRegistryCatalogDataCommand")
+    .f(void 0, void 0)
+    .ser(se_GetRegistryCatalogDataCommand)
+    .de(de_GetRegistryCatalogDataCommand)
+    .build() {
+}
-// src/commands/TagResourceCommand.ts
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "GetRepositoryCatalogData", {})
+    .n("ECRPUBLICClient", "GetRepositoryCatalogDataCommand")
+    .f(void 0, void 0)
+    .ser(se_GetRepositoryCatalogDataCommand)
+    .de(de_GetRepositoryCatalogDataCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "GetRepositoryPolicy", {})
+    .n("ECRPUBLICClient", "GetRepositoryPolicyCommand")
+    .f(void 0, void 0)
+    .ser(se_GetRepositoryPolicyCommand)
+    .de(de_GetRepositoryPolicyCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "InitiateLayerUpload", {})
+    .n("ECRPUBLICClient", "InitiateLayerUploadCommand")
+    .f(void 0, void 0)
+    .ser(se_InitiateLayerUploadCommand)
+    .de(de_InitiateLayerUploadCommand)
+    .build() {
+}
-var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "TagResource", {}).n("ECRPUBLICClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
-  static {
-    __name(this, "TagResourceCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "ListTagsForResource", {})
+    .n("ECRPUBLICClient", "ListTagsForResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_ListTagsForResourceCommand)
+    .de(de_ListTagsForResourceCommand)
+    .build() {
+}
-// src/commands/UntagResourceCommand.ts
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "PutImage", {})
+    .n("ECRPUBLICClient", "PutImageCommand")
+    .f(void 0, void 0)
+    .ser(se_PutImageCommand)
+    .de(de_PutImageCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "PutRegistryCatalogData", {})
+    .n("ECRPUBLICClient", "PutRegistryCatalogDataCommand")
+    .f(void 0, void 0)
+    .ser(se_PutRegistryCatalogDataCommand)
+    .de(de_PutRegistryCatalogDataCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "PutRepositoryCatalogData", {})
+    .n("ECRPUBLICClient", "PutRepositoryCatalogDataCommand")
+    .f(void 0, void 0)
+    .ser(se_PutRepositoryCatalogDataCommand)
+    .de(de_PutRepositoryCatalogDataCommand)
+    .build() {
+}
-var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "UntagResource", {}).n("ECRPUBLICClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
-  static {
-    __name(this, "UntagResourceCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "SetRepositoryPolicy", {})
+    .n("ECRPUBLICClient", "SetRepositoryPolicyCommand")
+    .f(void 0, void 0)
+    .ser(se_SetRepositoryPolicyCommand)
+    .de(de_SetRepositoryPolicyCommand)
+    .build() {
+}
-// src/commands/UploadLayerPartCommand.ts
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "TagResource", {})
+    .n("ECRPUBLICClient", "TagResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_TagResourceCommand)
+    .de(de_TagResourceCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "UntagResource", {})
+    .n("ECRPUBLICClient", "UntagResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_UntagResourceCommand)
+    .de(de_UntagResourceCommand)
+    .build() {
+}
+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()),
+    ];
+})
+    .s("SpencerFrontendService", "UploadLayerPart", {})
+    .n("ECRPUBLICClient", "UploadLayerPartCommand")
+    .f(void 0, void 0)
+    .ser(se_UploadLayerPartCommand)
+    .de(de_UploadLayerPartCommand)
+    .build() {
+}
-var UploadLayerPartCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SpencerFrontendService", "UploadLayerPart", {}).n("ECRPUBLICClient", "UploadLayerPartCommand").f(void 0, void 0).ser(se_UploadLayerPartCommand).de(de_UploadLayerPartCommand).build() {
-  static {
-    __name(this, "UploadLayerPartCommand");
-  }
+const commands = {
+    BatchCheckLayerAvailabilityCommand,
+    BatchDeleteImageCommand,
+    CompleteLayerUploadCommand,
+    CreateRepositoryCommand,
+    DeleteRepositoryCommand,
+    DeleteRepositoryPolicyCommand,
+    DescribeImagesCommand,
+    DescribeImageTagsCommand,
+    DescribeRegistriesCommand,
+    DescribeRepositoriesCommand,
+    GetAuthorizationTokenCommand,
+    GetRegistryCatalogDataCommand,
+    GetRepositoryCatalogDataCommand,
+    GetRepositoryPolicyCommand,
+    InitiateLayerUploadCommand,
+    ListTagsForResourceCommand,
+    PutImageCommand,
+    PutRegistryCatalogDataCommand,
+    PutRepositoryCatalogDataCommand,
+    SetRepositoryPolicyCommand,
+    TagResourceCommand,
+    UntagResourceCommand,
+    UploadLayerPartCommand,
 };
+class ECRPUBLIC extends ECRPUBLICClient {
+}
+smithyClient.createAggregatedClient(commands, ECRPUBLIC);
-// src/ECRPUBLIC.ts
-var commands = {
-  BatchCheckLayerAvailabilityCommand,
-  BatchDeleteImageCommand,
-  CompleteLayerUploadCommand,
-  CreateRepositoryCommand,
-  DeleteRepositoryCommand,
-  DeleteRepositoryPolicyCommand,
-  DescribeImagesCommand,
-  DescribeImageTagsCommand,
-  DescribeRegistriesCommand,
-  DescribeRepositoriesCommand,
-  GetAuthorizationTokenCommand,
-  GetRegistryCatalogDataCommand,
-  GetRepositoryCatalogDataCommand,
-  GetRepositoryPolicyCommand,
-  InitiateLayerUploadCommand,
-  ListTagsForResourceCommand,
-  PutImageCommand,
-  PutRegistryCatalogDataCommand,
-  PutRepositoryCatalogDataCommand,
-  SetRepositoryPolicyCommand,
-  TagResourceCommand,
-  UntagResourceCommand,
-  UploadLayerPartCommand
-};
-var ECRPUBLIC = class extends ECRPUBLICClient {
-  static {
-    __name(this, "ECRPUBLIC");
-  }
-};
-(0, import_smithy_client.createAggregatedClient)(commands, ECRPUBLIC);
-// src/pagination/DescribeImageTagsPaginator.ts
-var paginateDescribeImageTags = (0, import_core.createPaginator)(ECRPUBLICClient, DescribeImageTagsCommand, "nextToken", "nextToken", "maxResults");
-// src/pagination/DescribeImagesPaginator.ts
-var paginateDescribeImages = (0, import_core.createPaginator)(ECRPUBLICClient, DescribeImagesCommand, "nextToken", "nextToken", "maxResults");
-// src/pagination/DescribeRegistriesPaginator.ts
+const paginateDescribeImageTags = core.createPaginator(ECRPUBLICClient, DescribeImageTagsCommand, "nextToken", "nextToken", "maxResults");
-var paginateDescribeRegistries = (0, import_core.createPaginator)(ECRPUBLICClient, DescribeRegistriesCommand, "nextToken", "nextToken", "maxResults");
+const paginateDescribeImages = core.createPaginator(ECRPUBLICClient, DescribeImagesCommand, "nextToken", "nextToken", "maxResults");
-// src/pagination/DescribeRepositoriesPaginator.ts
+const paginateDescribeRegistries = core.createPaginator(ECRPUBLICClient, DescribeRegistriesCommand, "nextToken", "nextToken", "maxResults");
-var paginateDescribeRepositories = (0, import_core.createPaginator)(ECRPUBLICClient, DescribeRepositoriesCommand, "nextToken", "nextToken", "maxResults");
-// Annotate the CommonJS export names for ESM import in node:
+const paginateDescribeRepositories = core.createPaginator(ECRPUBLICClient, DescribeRepositoriesCommand, "nextToken", "nextToken", "maxResults");
-0 && (module.exports = {
-  ECRPUBLICServiceException,
-  __Client,
-  ECRPUBLICClient,
-  ECRPUBLIC,
-  $Command,
-  BatchCheckLayerAvailabilityCommand,
-  BatchDeleteImageCommand,
-  CompleteLayerUploadCommand,
-  CreateRepositoryCommand,
-  DeleteRepositoryCommand,
-  DeleteRepositoryPolicyCommand,
-  DescribeImageTagsCommand,
-  DescribeImagesCommand,
-  DescribeRegistriesCommand,
-  DescribeRepositoriesCommand,
-  GetAuthorizationTokenCommand,
-  GetRegistryCatalogDataCommand,
-  GetRepositoryCatalogDataCommand,
-  GetRepositoryPolicyCommand,
-  InitiateLayerUploadCommand,
-  ListTagsForResourceCommand,
-  PutImageCommand,
-  PutRegistryCatalogDataCommand,
-  PutRepositoryCatalogDataCommand,
-  SetRepositoryPolicyCommand,
-  TagResourceCommand,
-  UntagResourceCommand,
-  UploadLayerPartCommand,
-  paginateDescribeImageTags,
-  paginateDescribeImages,
-  paginateDescribeRegistries,
-  paginateDescribeRepositories,
-  LayerFailureCode,
-  LayerAvailability,
-  InvalidParameterException,
-  RegistryNotFoundException,
-  RepositoryNotFoundException,
-  ServerException,
-  UnsupportedCommandException,
-  ImageFailureCode,
-  EmptyUploadException,
-  InvalidLayerException,
-  LayerAlreadyExistsException,
-  LayerPartTooSmallException,
-  UploadNotFoundException,
-  InvalidTagParameterException,
-  LimitExceededException,
-  RepositoryAlreadyExistsException,
-  TooManyTagsException,
-  RepositoryNotEmptyException,
-  RepositoryPolicyNotFoundException,
-  ImageNotFoundException,
-  RegistryAliasStatus,
-  RepositoryCatalogDataNotFoundException,
-  ImageAlreadyExistsException,
-  ImageDigestDoesNotMatchException,
-  ImageTagAlreadyExistsException,
-  InvalidLayerPartException,
-  LayersNotFoundException,
-  ReferencedImagesNotFoundException
+Object.defineProperty(exports, "$Command", {
+    enumerable: true,
+    get: function () { return smithyClient.Command; }
 });
+Object.defineProperty(exports, "__Client", {
+    enumerable: true,
+    get: function () { return smithyClient.Client; }
+});
+exports.BatchCheckLayerAvailabilityCommand = BatchCheckLayerAvailabilityCommand;
+exports.BatchDeleteImageCommand = BatchDeleteImageCommand;
+exports.CompleteLayerUploadCommand = CompleteLayerUploadCommand;
+exports.CreateRepositoryCommand = CreateRepositoryCommand;
+exports.DeleteRepositoryCommand = DeleteRepositoryCommand;
+exports.DeleteRepositoryPolicyCommand = DeleteRepositoryPolicyCommand;
+exports.DescribeImageTagsCommand = DescribeImageTagsCommand;
+exports.DescribeImagesCommand = DescribeImagesCommand;
+exports.DescribeRegistriesCommand = DescribeRegistriesCommand;
+exports.DescribeRepositoriesCommand = DescribeRepositoriesCommand;
+exports.ECRPUBLIC = ECRPUBLIC;
+exports.ECRPUBLICClient = ECRPUBLICClient;
+exports.ECRPUBLICServiceException = ECRPUBLICServiceException;
+exports.EmptyUploadException = EmptyUploadException;
+exports.GetAuthorizationTokenCommand = GetAuthorizationTokenCommand;
+exports.GetRegistryCatalogDataCommand = GetRegistryCatalogDataCommand;
+exports.GetRepositoryCatalogDataCommand = GetRepositoryCatalogDataCommand;
+exports.GetRepositoryPolicyCommand = GetRepositoryPolicyCommand;
+exports.ImageAlreadyExistsException = ImageAlreadyExistsException;
+exports.ImageDigestDoesNotMatchException = ImageDigestDoesNotMatchException;
+exports.ImageFailureCode = ImageFailureCode;
+exports.ImageNotFoundException = ImageNotFoundException;
+exports.ImageTagAlreadyExistsException = ImageTagAlreadyExistsException;
+exports.InitiateLayerUploadCommand = InitiateLayerUploadCommand;
+exports.InvalidLayerException = InvalidLayerException;
+exports.InvalidLayerPartException = InvalidLayerPartException;
+exports.InvalidParameterException = InvalidParameterException;
+exports.InvalidTagParameterException = InvalidTagParameterException;
+exports.LayerAlreadyExistsException = LayerAlreadyExistsException;
+exports.LayerAvailability = LayerAvailability;
+exports.LayerFailureCode = LayerFailureCode;
+exports.LayerPartTooSmallException = LayerPartTooSmallException;
+exports.LayersNotFoundException = LayersNotFoundException;
+exports.LimitExceededException = LimitExceededException;
+exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.PutImageCommand = PutImageCommand;
+exports.PutRegistryCatalogDataCommand = PutRegistryCatalogDataCommand;
+exports.PutRepositoryCatalogDataCommand = PutRepositoryCatalogDataCommand;
+exports.ReferencedImagesNotFoundException = ReferencedImagesNotFoundException;
+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.SetRepositoryPolicyCommand = SetRepositoryPolicyCommand;
+exports.TagResourceCommand = TagResourceCommand;
+exports.TooManyTagsException = TooManyTagsException;
+exports.UnsupportedCommandException = UnsupportedCommandException;
+exports.UntagResourceCommand = UntagResourceCommand;
+exports.UploadLayerPartCommand = UploadLayerPartCommand;
+exports.UploadNotFoundException = UploadNotFoundException;
+exports.paginateDescribeImageTags = paginateDescribeImageTags;
+exports.paginateDescribeImages = paginateDescribeImages;
+exports.paginateDescribeRegistries = paginateDescribeRegistries;
+exports.paginateDescribeRepositories = paginateDescribeRepositories;