@aws-sdk/client-ecr 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,13 +1,4823 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ECRServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ECRClient"), exports);
-tslib_1.__exportStar(require("./ECR"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var ECRServiceException_1 = require("./models/ECRServiceException");
-Object.defineProperty(exports, "ECRServiceException", { enumerable: true, get: function () { return ECRServiceException_1.ECRServiceException; } });
+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 src_exports = {};
+__export(src_exports, {
+  BatchCheckLayerAvailabilityCommand: () => BatchCheckLayerAvailabilityCommand,
+  BatchDeleteImageCommand: () => BatchDeleteImageCommand,
+  BatchGetImageCommand: () => BatchGetImageCommand,
+  BatchGetRepositoryScanningConfigurationCommand: () => BatchGetRepositoryScanningConfigurationCommand,
+  CompleteLayerUploadCommand: () => CompleteLayerUploadCommand,
+  CreatePullThroughCacheRuleCommand: () => CreatePullThroughCacheRuleCommand,
+  CreateRepositoryCommand: () => CreateRepositoryCommand,
+  DeleteLifecyclePolicyCommand: () => DeleteLifecyclePolicyCommand,
+  DeletePullThroughCacheRuleCommand: () => DeletePullThroughCacheRuleCommand,
+  DeleteRegistryPolicyCommand: () => DeleteRegistryPolicyCommand,
+  DeleteRepositoryCommand: () => DeleteRepositoryCommand,
+  DeleteRepositoryPolicyCommand: () => DeleteRepositoryPolicyCommand,
+  DescribeImageReplicationStatusCommand: () => DescribeImageReplicationStatusCommand,
+  DescribeImageScanFindingsCommand: () => DescribeImageScanFindingsCommand,
+  DescribeImagesCommand: () => DescribeImagesCommand,
+  DescribePullThroughCacheRulesCommand: () => DescribePullThroughCacheRulesCommand,
+  DescribeRegistryCommand: () => DescribeRegistryCommand,
+  DescribeRepositoriesCommand: () => DescribeRepositoriesCommand,
+  ECR: () => ECR,
+  ECRClient: () => ECRClient,
+  ECRServiceException: () => ECRServiceException,
+  EmptyUploadException: () => EmptyUploadException,
+  EncryptionType: () => EncryptionType,
+  FindingSeverity: () => FindingSeverity,
+  GetAuthorizationTokenCommand: () => GetAuthorizationTokenCommand,
+  GetDownloadUrlForLayerCommand: () => GetDownloadUrlForLayerCommand,
+  GetLifecyclePolicyCommand: () => GetLifecyclePolicyCommand,
+  GetLifecyclePolicyPreviewCommand: () => GetLifecyclePolicyPreviewCommand,
+  GetRegistryPolicyCommand: () => GetRegistryPolicyCommand,
+  GetRegistryScanningConfigurationCommand: () => GetRegistryScanningConfigurationCommand,
+  GetRepositoryPolicyCommand: () => GetRepositoryPolicyCommand,
+  ImageActionType: () => ImageActionType,
+  ImageAlreadyExistsException: () => ImageAlreadyExistsException,
+  ImageDigestDoesNotMatchException: () => ImageDigestDoesNotMatchException,
+  ImageFailureCode: () => ImageFailureCode,
+  ImageNotFoundException: () => ImageNotFoundException,
+  ImageTagAlreadyExistsException: () => ImageTagAlreadyExistsException,
+  ImageTagMutability: () => ImageTagMutability,
+  InitiateLayerUploadCommand: () => InitiateLayerUploadCommand,
+  InvalidLayerException: () => InvalidLayerException,
+  InvalidLayerPartException: () => InvalidLayerPartException,
+  InvalidParameterException: () => InvalidParameterException,
+  InvalidTagParameterException: () => InvalidTagParameterException,
+  KmsException: () => KmsException,
+  LayerAlreadyExistsException: () => LayerAlreadyExistsException,
+  LayerAvailability: () => LayerAvailability,
+  LayerFailureCode: () => LayerFailureCode,
+  LayerInaccessibleException: () => LayerInaccessibleException,
+  LayerPartTooSmallException: () => LayerPartTooSmallException,
+  LayersNotFoundException: () => LayersNotFoundException,
+  LifecyclePolicyNotFoundException: () => LifecyclePolicyNotFoundException,
+  LifecyclePolicyPreviewInProgressException: () => LifecyclePolicyPreviewInProgressException,
+  LifecyclePolicyPreviewNotFoundException: () => LifecyclePolicyPreviewNotFoundException,
+  LifecyclePolicyPreviewStatus: () => LifecyclePolicyPreviewStatus,
+  LimitExceededException: () => LimitExceededException,
+  ListImagesCommand: () => ListImagesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  PullThroughCacheRuleAlreadyExistsException: () => PullThroughCacheRuleAlreadyExistsException,
+  PullThroughCacheRuleNotFoundException: () => PullThroughCacheRuleNotFoundException,
+  PutImageCommand: () => PutImageCommand,
+  PutImageScanningConfigurationCommand: () => PutImageScanningConfigurationCommand,
+  PutImageTagMutabilityCommand: () => PutImageTagMutabilityCommand,
+  PutLifecyclePolicyCommand: () => PutLifecyclePolicyCommand,
+  PutRegistryPolicyCommand: () => PutRegistryPolicyCommand,
+  PutRegistryScanningConfigurationCommand: () => PutRegistryScanningConfigurationCommand,
+  PutReplicationConfigurationCommand: () => PutReplicationConfigurationCommand,
+  ReferencedImagesNotFoundException: () => ReferencedImagesNotFoundException,
+  RegistryPolicyNotFoundException: () => RegistryPolicyNotFoundException,
+  ReplicationStatus: () => ReplicationStatus,
+  RepositoryAlreadyExistsException: () => RepositoryAlreadyExistsException,
+  RepositoryFilterType: () => RepositoryFilterType,
+  RepositoryNotEmptyException: () => RepositoryNotEmptyException,
+  RepositoryNotFoundException: () => RepositoryNotFoundException,
+  RepositoryPolicyNotFoundException: () => RepositoryPolicyNotFoundException,
+  ScanFrequency: () => ScanFrequency,
+  ScanNotFoundException: () => ScanNotFoundException,
+  ScanStatus: () => ScanStatus,
+  ScanType: () => ScanType,
+  ScanningConfigurationFailureCode: () => ScanningConfigurationFailureCode,
+  ScanningRepositoryFilterType: () => ScanningRepositoryFilterType,
+  SecretNotFoundException: () => SecretNotFoundException,
+  ServerException: () => ServerException,
+  SetRepositoryPolicyCommand: () => SetRepositoryPolicyCommand,
+  StartImageScanCommand: () => StartImageScanCommand,
+  StartLifecyclePolicyPreviewCommand: () => StartLifecyclePolicyPreviewCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TagStatus: () => TagStatus,
+  TooManyTagsException: () => TooManyTagsException,
+  UnableToAccessSecretException: () => UnableToAccessSecretException,
+  UnableToDecryptSecretValueException: () => UnableToDecryptSecretValueException,
+  UnableToGetUpstreamImageException: () => UnableToGetUpstreamImageException,
+  UnableToGetUpstreamLayerException: () => UnableToGetUpstreamLayerException,
+  UnsupportedImageTypeException: () => UnsupportedImageTypeException,
+  UnsupportedUpstreamRegistryException: () => UnsupportedUpstreamRegistryException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdatePullThroughCacheRuleCommand: () => UpdatePullThroughCacheRuleCommand,
+  UploadLayerPartCommand: () => UploadLayerPartCommand,
+  UploadNotFoundException: () => UploadNotFoundException,
+  UpstreamRegistry: () => UpstreamRegistry,
+  ValidatePullThroughCacheRuleCommand: () => ValidatePullThroughCacheRuleCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeImageScanFindings: () => paginateDescribeImageScanFindings,
+  paginateDescribeImages: () => paginateDescribeImages,
+  paginateDescribePullThroughCacheRules: () => paginateDescribePullThroughCacheRules,
+  paginateDescribeRepositories: () => paginateDescribeRepositories,
+  paginateGetLifecyclePolicyPreview: () => paginateGetLifecyclePolicyPreview,
+  paginateListImages: () => paginateListImages,
+  waitForImageScanComplete: () => waitForImageScanComplete,
+  waitForLifecyclePolicyPreviewComplete: () => waitForLifecyclePolicyPreviewComplete,
+  waitUntilImageScanComplete: () => waitUntilImageScanComplete,
+  waitUntilLifecyclePolicyPreviewComplete: () => waitUntilLifecyclePolicyPreviewComplete
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ECRClient.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_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+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");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "ecr"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ECRClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// 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");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/ECRClient.ts
+var _ECRClient = class _ECRClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    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_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(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();
+  }
+};
+__name(_ECRClient, "ECRClient");
+var ECRClient = _ECRClient;
+
+// src/ECR.ts
+
+
+// src/commands/BatchCheckLayerAvailabilityCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/ECRServiceException.ts
+
+var _ECRServiceException = class _ECRServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ECRServiceException.prototype);
+  }
+};
+__name(_ECRServiceException, "ECRServiceException");
+var ECRServiceException = _ECRServiceException;
+
+// src/models/models_0.ts
+var LayerFailureCode = {
+  InvalidLayerDigest: "InvalidLayerDigest",
+  MissingLayerDigest: "MissingLayerDigest"
+};
+var LayerAvailability = {
+  AVAILABLE: "AVAILABLE",
+  UNAVAILABLE: "UNAVAILABLE"
+};
+var _InvalidParameterException = class _InvalidParameterException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
+  }
+};
+__name(_InvalidParameterException, "InvalidParameterException");
+var InvalidParameterException = _InvalidParameterException;
+var _RepositoryNotFoundException = class _RepositoryNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RepositoryNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RepositoryNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RepositoryNotFoundException.prototype);
+  }
+};
+__name(_RepositoryNotFoundException, "RepositoryNotFoundException");
+var RepositoryNotFoundException = _RepositoryNotFoundException;
+var _ServerException = class _ServerException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServerException.prototype);
+  }
+};
+__name(_ServerException, "ServerException");
+var ServerException = _ServerException;
+var ImageFailureCode = {
+  ImageNotFound: "ImageNotFound",
+  ImageReferencedByManifestList: "ImageReferencedByManifestList",
+  ImageTagDoesNotMatchDigest: "ImageTagDoesNotMatchDigest",
+  InvalidImageDigest: "InvalidImageDigest",
+  InvalidImageTag: "InvalidImageTag",
+  KmsError: "KmsError",
+  MissingDigestAndTag: "MissingDigestAndTag",
+  UpstreamAccessDenied: "UpstreamAccessDenied",
+  UpstreamTooManyRequests: "UpstreamTooManyRequests",
+  UpstreamUnavailable: "UpstreamUnavailable"
+};
+var _LimitExceededException = class _LimitExceededException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _UnableToGetUpstreamImageException = class _UnableToGetUpstreamImageException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnableToGetUpstreamImageException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnableToGetUpstreamImageException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnableToGetUpstreamImageException.prototype);
+  }
+};
+__name(_UnableToGetUpstreamImageException, "UnableToGetUpstreamImageException");
+var UnableToGetUpstreamImageException = _UnableToGetUpstreamImageException;
+var ScanningConfigurationFailureCode = {
+  REPOSITORY_NOT_FOUND: "REPOSITORY_NOT_FOUND"
+};
+var ScanningRepositoryFilterType = {
+  WILDCARD: "WILDCARD"
+};
+var ScanFrequency = {
+  CONTINUOUS_SCAN: "CONTINUOUS_SCAN",
+  MANUAL: "MANUAL",
+  SCAN_ON_PUSH: "SCAN_ON_PUSH"
+};
+var _ValidationException = class _ValidationException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _EmptyUploadException = class _EmptyUploadException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "EmptyUploadException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "EmptyUploadException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _EmptyUploadException.prototype);
+  }
+};
+__name(_EmptyUploadException, "EmptyUploadException");
+var EmptyUploadException = _EmptyUploadException;
+var _InvalidLayerException = class _InvalidLayerException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidLayerException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidLayerException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidLayerException.prototype);
+  }
+};
+__name(_InvalidLayerException, "InvalidLayerException");
+var InvalidLayerException = _InvalidLayerException;
+var _KmsException = class _KmsException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "KmsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "KmsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _KmsException.prototype);
+    this.kmsError = opts.kmsError;
+  }
+};
+__name(_KmsException, "KmsException");
+var KmsException = _KmsException;
+var _LayerAlreadyExistsException = class _LayerAlreadyExistsException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LayerAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LayerAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LayerAlreadyExistsException.prototype);
+  }
+};
+__name(_LayerAlreadyExistsException, "LayerAlreadyExistsException");
+var LayerAlreadyExistsException = _LayerAlreadyExistsException;
+var _LayerPartTooSmallException = class _LayerPartTooSmallException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LayerPartTooSmallException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LayerPartTooSmallException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LayerPartTooSmallException.prototype);
+  }
+};
+__name(_LayerPartTooSmallException, "LayerPartTooSmallException");
+var LayerPartTooSmallException = _LayerPartTooSmallException;
+var _UploadNotFoundException = class _UploadNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UploadNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UploadNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UploadNotFoundException.prototype);
+  }
+};
+__name(_UploadNotFoundException, "UploadNotFoundException");
+var UploadNotFoundException = _UploadNotFoundException;
+var UpstreamRegistry = {
+  AzureContainerRegistry: "azure-container-registry",
+  DockerHub: "docker-hub",
+  EcrPublic: "ecr-public",
+  GitHubContainerRegistry: "github-container-registry",
+  K8s: "k8s",
+  Quay: "quay"
+};
+var _PullThroughCacheRuleAlreadyExistsException = class _PullThroughCacheRuleAlreadyExistsException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PullThroughCacheRuleAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PullThroughCacheRuleAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PullThroughCacheRuleAlreadyExistsException.prototype);
+  }
+};
+__name(_PullThroughCacheRuleAlreadyExistsException, "PullThroughCacheRuleAlreadyExistsException");
+var PullThroughCacheRuleAlreadyExistsException = _PullThroughCacheRuleAlreadyExistsException;
+var _SecretNotFoundException = class _SecretNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SecretNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SecretNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SecretNotFoundException.prototype);
+  }
+};
+__name(_SecretNotFoundException, "SecretNotFoundException");
+var SecretNotFoundException = _SecretNotFoundException;
+var _UnableToAccessSecretException = class _UnableToAccessSecretException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnableToAccessSecretException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnableToAccessSecretException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnableToAccessSecretException.prototype);
+  }
+};
+__name(_UnableToAccessSecretException, "UnableToAccessSecretException");
+var UnableToAccessSecretException = _UnableToAccessSecretException;
+var _UnableToDecryptSecretValueException = class _UnableToDecryptSecretValueException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnableToDecryptSecretValueException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnableToDecryptSecretValueException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnableToDecryptSecretValueException.prototype);
+  }
+};
+__name(_UnableToDecryptSecretValueException, "UnableToDecryptSecretValueException");
+var UnableToDecryptSecretValueException = _UnableToDecryptSecretValueException;
+var _UnsupportedUpstreamRegistryException = class _UnsupportedUpstreamRegistryException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedUpstreamRegistryException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedUpstreamRegistryException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedUpstreamRegistryException.prototype);
+  }
+};
+__name(_UnsupportedUpstreamRegistryException, "UnsupportedUpstreamRegistryException");
+var UnsupportedUpstreamRegistryException = _UnsupportedUpstreamRegistryException;
+var EncryptionType = {
+  AES256: "AES256",
+  KMS: "KMS"
+};
+var ImageTagMutability = {
+  IMMUTABLE: "IMMUTABLE",
+  MUTABLE: "MUTABLE"
+};
+var _InvalidTagParameterException = class _InvalidTagParameterException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidTagParameterException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidTagParameterException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidTagParameterException.prototype);
+  }
+};
+__name(_InvalidTagParameterException, "InvalidTagParameterException");
+var InvalidTagParameterException = _InvalidTagParameterException;
+var _RepositoryAlreadyExistsException = class _RepositoryAlreadyExistsException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RepositoryAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RepositoryAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RepositoryAlreadyExistsException.prototype);
+  }
+};
+__name(_RepositoryAlreadyExistsException, "RepositoryAlreadyExistsException");
+var RepositoryAlreadyExistsException = _RepositoryAlreadyExistsException;
+var _TooManyTagsException = class _TooManyTagsException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+var _LifecyclePolicyNotFoundException = class _LifecyclePolicyNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LifecyclePolicyNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LifecyclePolicyNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LifecyclePolicyNotFoundException.prototype);
+  }
+};
+__name(_LifecyclePolicyNotFoundException, "LifecyclePolicyNotFoundException");
+var LifecyclePolicyNotFoundException = _LifecyclePolicyNotFoundException;
+var _PullThroughCacheRuleNotFoundException = class _PullThroughCacheRuleNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PullThroughCacheRuleNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PullThroughCacheRuleNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PullThroughCacheRuleNotFoundException.prototype);
+  }
+};
+__name(_PullThroughCacheRuleNotFoundException, "PullThroughCacheRuleNotFoundException");
+var PullThroughCacheRuleNotFoundException = _PullThroughCacheRuleNotFoundException;
+var _RegistryPolicyNotFoundException = class _RegistryPolicyNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RegistryPolicyNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RegistryPolicyNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RegistryPolicyNotFoundException.prototype);
+  }
+};
+__name(_RegistryPolicyNotFoundException, "RegistryPolicyNotFoundException");
+var RegistryPolicyNotFoundException = _RegistryPolicyNotFoundException;
+var _RepositoryNotEmptyException = class _RepositoryNotEmptyException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RepositoryNotEmptyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RepositoryNotEmptyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RepositoryNotEmptyException.prototype);
+  }
+};
+__name(_RepositoryNotEmptyException, "RepositoryNotEmptyException");
+var RepositoryNotEmptyException = _RepositoryNotEmptyException;
+var _RepositoryPolicyNotFoundException = class _RepositoryPolicyNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RepositoryPolicyNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RepositoryPolicyNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RepositoryPolicyNotFoundException.prototype);
+  }
+};
+__name(_RepositoryPolicyNotFoundException, "RepositoryPolicyNotFoundException");
+var RepositoryPolicyNotFoundException = _RepositoryPolicyNotFoundException;
+var ReplicationStatus = {
+  COMPLETE: "COMPLETE",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS"
+};
+var _ImageNotFoundException = class _ImageNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ImageNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ImageNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ImageNotFoundException.prototype);
+  }
+};
+__name(_ImageNotFoundException, "ImageNotFoundException");
+var ImageNotFoundException = _ImageNotFoundException;
+var TagStatus = {
+  ANY: "ANY",
+  TAGGED: "TAGGED",
+  UNTAGGED: "UNTAGGED"
+};
+var FindingSeverity = {
+  CRITICAL: "CRITICAL",
+  HIGH: "HIGH",
+  INFORMATIONAL: "INFORMATIONAL",
+  LOW: "LOW",
+  MEDIUM: "MEDIUM",
+  UNDEFINED: "UNDEFINED"
+};
+var ScanStatus = {
+  ACTIVE: "ACTIVE",
+  COMPLETE: "COMPLETE",
+  FAILED: "FAILED",
+  FINDINGS_UNAVAILABLE: "FINDINGS_UNAVAILABLE",
+  IN_PROGRESS: "IN_PROGRESS",
+  PENDING: "PENDING",
+  SCAN_ELIGIBILITY_EXPIRED: "SCAN_ELIGIBILITY_EXPIRED",
+  UNSUPPORTED_IMAGE: "UNSUPPORTED_IMAGE"
+};
+var _ScanNotFoundException = class _ScanNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ScanNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ScanNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ScanNotFoundException.prototype);
+  }
+};
+__name(_ScanNotFoundException, "ScanNotFoundException");
+var ScanNotFoundException = _ScanNotFoundException;
+var RepositoryFilterType = {
+  PREFIX_MATCH: "PREFIX_MATCH"
+};
+var _LayerInaccessibleException = class _LayerInaccessibleException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LayerInaccessibleException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LayerInaccessibleException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LayerInaccessibleException.prototype);
+  }
+};
+__name(_LayerInaccessibleException, "LayerInaccessibleException");
+var LayerInaccessibleException = _LayerInaccessibleException;
+var _LayersNotFoundException = class _LayersNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LayersNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LayersNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LayersNotFoundException.prototype);
+  }
+};
+__name(_LayersNotFoundException, "LayersNotFoundException");
+var LayersNotFoundException = _LayersNotFoundException;
+var _UnableToGetUpstreamLayerException = class _UnableToGetUpstreamLayerException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnableToGetUpstreamLayerException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnableToGetUpstreamLayerException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnableToGetUpstreamLayerException.prototype);
+  }
+};
+__name(_UnableToGetUpstreamLayerException, "UnableToGetUpstreamLayerException");
+var UnableToGetUpstreamLayerException = _UnableToGetUpstreamLayerException;
+var ImageActionType = {
+  EXPIRE: "EXPIRE"
+};
+var LifecyclePolicyPreviewStatus = {
+  COMPLETE: "COMPLETE",
+  EXPIRED: "EXPIRED",
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS"
+};
+var _LifecyclePolicyPreviewNotFoundException = class _LifecyclePolicyPreviewNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LifecyclePolicyPreviewNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LifecyclePolicyPreviewNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LifecyclePolicyPreviewNotFoundException.prototype);
+  }
+};
+__name(_LifecyclePolicyPreviewNotFoundException, "LifecyclePolicyPreviewNotFoundException");
+var LifecyclePolicyPreviewNotFoundException = _LifecyclePolicyPreviewNotFoundException;
+var ScanType = {
+  BASIC: "BASIC",
+  ENHANCED: "ENHANCED"
+};
+var _ImageAlreadyExistsException = class _ImageAlreadyExistsException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ImageAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ImageAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ImageAlreadyExistsException.prototype);
+  }
+};
+__name(_ImageAlreadyExistsException, "ImageAlreadyExistsException");
+var ImageAlreadyExistsException = _ImageAlreadyExistsException;
+var _ImageDigestDoesNotMatchException = class _ImageDigestDoesNotMatchException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ImageDigestDoesNotMatchException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ImageDigestDoesNotMatchException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ImageDigestDoesNotMatchException.prototype);
+  }
+};
+__name(_ImageDigestDoesNotMatchException, "ImageDigestDoesNotMatchException");
+var ImageDigestDoesNotMatchException = _ImageDigestDoesNotMatchException;
+var _ImageTagAlreadyExistsException = class _ImageTagAlreadyExistsException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ImageTagAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ImageTagAlreadyExistsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ImageTagAlreadyExistsException.prototype);
+  }
+};
+__name(_ImageTagAlreadyExistsException, "ImageTagAlreadyExistsException");
+var ImageTagAlreadyExistsException = _ImageTagAlreadyExistsException;
+var _ReferencedImagesNotFoundException = class _ReferencedImagesNotFoundException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ReferencedImagesNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ReferencedImagesNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ReferencedImagesNotFoundException.prototype);
+  }
+};
+__name(_ReferencedImagesNotFoundException, "ReferencedImagesNotFoundException");
+var ReferencedImagesNotFoundException = _ReferencedImagesNotFoundException;
+var _UnsupportedImageTypeException = class _UnsupportedImageTypeException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedImageTypeException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedImageTypeException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedImageTypeException.prototype);
+  }
+};
+__name(_UnsupportedImageTypeException, "UnsupportedImageTypeException");
+var UnsupportedImageTypeException = _UnsupportedImageTypeException;
+var _LifecyclePolicyPreviewInProgressException = class _LifecyclePolicyPreviewInProgressException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LifecyclePolicyPreviewInProgressException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LifecyclePolicyPreviewInProgressException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LifecyclePolicyPreviewInProgressException.prototype);
+  }
+};
+__name(_LifecyclePolicyPreviewInProgressException, "LifecyclePolicyPreviewInProgressException");
+var LifecyclePolicyPreviewInProgressException = _LifecyclePolicyPreviewInProgressException;
+var _InvalidLayerPartException = class _InvalidLayerPartException extends ECRServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidLayerPartException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidLayerPartException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidLayerPartException.prototype);
+    this.registryId = opts.registryId;
+    this.repositoryName = opts.repositoryName;
+    this.uploadId = opts.uploadId;
+    this.lastValidByteReceived = opts.lastValidByteReceived;
+  }
+};
+__name(_InvalidLayerPartException, "InvalidLayerPartException");
+var InvalidLayerPartException = _InvalidLayerPartException;
+
+// 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_BatchGetImageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("BatchGetImage");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_BatchGetImageCommand");
+var se_BatchGetRepositoryScanningConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("BatchGetRepositoryScanningConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_BatchGetRepositoryScanningConfigurationCommand");
+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_CreatePullThroughCacheRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreatePullThroughCacheRule");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreatePullThroughCacheRuleCommand");
+var se_CreateRepositoryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateRepository");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateRepositoryCommand");
+var se_DeleteLifecyclePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteLifecyclePolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteLifecyclePolicyCommand");
+var se_DeletePullThroughCacheRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeletePullThroughCacheRule");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeletePullThroughCacheRuleCommand");
+var se_DeleteRegistryPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteRegistryPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteRegistryPolicyCommand");
+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_DescribeImageReplicationStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeImageReplicationStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeImageReplicationStatusCommand");
+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_DescribeImageScanFindingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeImageScanFindings");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeImageScanFindingsCommand");
+var se_DescribePullThroughCacheRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribePullThroughCacheRules");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribePullThroughCacheRulesCommand");
+var se_DescribeRegistryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeRegistry");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeRegistryCommand");
+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_GetDownloadUrlForLayerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetDownloadUrlForLayer");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetDownloadUrlForLayerCommand");
+var se_GetLifecyclePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetLifecyclePolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetLifecyclePolicyCommand");
+var se_GetLifecyclePolicyPreviewCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetLifecyclePolicyPreview");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetLifecyclePolicyPreviewCommand");
+var se_GetRegistryPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetRegistryPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetRegistryPolicyCommand");
+var se_GetRegistryScanningConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetRegistryScanningConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetRegistryScanningConfigurationCommand");
+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_ListImagesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListImages");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListImagesCommand");
+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_PutImageScanningConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutImageScanningConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutImageScanningConfigurationCommand");
+var se_PutImageTagMutabilityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutImageTagMutability");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutImageTagMutabilityCommand");
+var se_PutLifecyclePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutLifecyclePolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutLifecyclePolicyCommand");
+var se_PutRegistryPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutRegistryPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutRegistryPolicyCommand");
+var se_PutRegistryScanningConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutRegistryScanningConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutRegistryScanningConfigurationCommand");
+var se_PutReplicationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutReplicationConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutReplicationConfigurationCommand");
+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_StartImageScanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartImageScan");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartImageScanCommand");
+var se_StartLifecyclePolicyPreviewCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartLifecyclePolicyPreview");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartLifecyclePolicyPreviewCommand");
+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_UpdatePullThroughCacheRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdatePullThroughCacheRule");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdatePullThroughCacheRuleCommand");
+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 se_ValidatePullThroughCacheRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ValidatePullThroughCacheRule");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ValidatePullThroughCacheRuleCommand");
+var de_BatchCheckLayerAvailabilityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_BatchCheckLayerAvailabilityCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_BatchCheckLayerAvailabilityCommand");
+var de_BatchCheckLayerAvailabilityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchCheckLayerAvailabilityCommandError");
+var de_BatchDeleteImageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_BatchDeleteImageCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_BatchDeleteImageCommand");
+var de_BatchDeleteImageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchDeleteImageCommandError");
+var de_BatchGetImageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_BatchGetImageCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_BatchGetImageCommand");
+var de_BatchGetImageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.ecr#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "UnableToGetUpstreamImageException":
+    case "com.amazonaws.ecr#UnableToGetUpstreamImageException":
+      throw await de_UnableToGetUpstreamImageExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchGetImageCommandError");
+var de_BatchGetRepositoryScanningConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_BatchGetRepositoryScanningConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_BatchGetRepositoryScanningConfigurationCommand");
+var de_BatchGetRepositoryScanningConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchGetRepositoryScanningConfigurationCommandError");
+var de_CompleteLayerUploadCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CompleteLayerUploadCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CompleteLayerUploadCommand");
+var de_CompleteLayerUploadCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "EmptyUploadException":
+    case "com.amazonaws.ecr#EmptyUploadException":
+      throw await de_EmptyUploadExceptionRes(parsedOutput, context);
+    case "InvalidLayerException":
+    case "com.amazonaws.ecr#InvalidLayerException":
+      throw await de_InvalidLayerExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "KmsException":
+    case "com.amazonaws.ecr#KmsException":
+      throw await de_KmsExceptionRes(parsedOutput, context);
+    case "LayerAlreadyExistsException":
+    case "com.amazonaws.ecr#LayerAlreadyExistsException":
+      throw await de_LayerAlreadyExistsExceptionRes(parsedOutput, context);
+    case "LayerPartTooSmallException":
+    case "com.amazonaws.ecr#LayerPartTooSmallException":
+      throw await de_LayerPartTooSmallExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "UploadNotFoundException":
+    case "com.amazonaws.ecr#UploadNotFoundException":
+      throw await de_UploadNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CompleteLayerUploadCommandError");
+var de_CreatePullThroughCacheRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreatePullThroughCacheRuleCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreatePullThroughCacheRuleResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreatePullThroughCacheRuleCommand");
+var de_CreatePullThroughCacheRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.ecr#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "PullThroughCacheRuleAlreadyExistsException":
+    case "com.amazonaws.ecr#PullThroughCacheRuleAlreadyExistsException":
+      throw await de_PullThroughCacheRuleAlreadyExistsExceptionRes(parsedOutput, context);
+    case "SecretNotFoundException":
+    case "com.amazonaws.ecr#SecretNotFoundException":
+      throw await de_SecretNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "UnableToAccessSecretException":
+    case "com.amazonaws.ecr#UnableToAccessSecretException":
+      throw await de_UnableToAccessSecretExceptionRes(parsedOutput, context);
+    case "UnableToDecryptSecretValueException":
+    case "com.amazonaws.ecr#UnableToDecryptSecretValueException":
+      throw await de_UnableToDecryptSecretValueExceptionRes(parsedOutput, context);
+    case "UnsupportedUpstreamRegistryException":
+    case "com.amazonaws.ecr#UnsupportedUpstreamRegistryException":
+      throw await de_UnsupportedUpstreamRegistryExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreatePullThroughCacheRuleCommandError");
+var de_CreateRepositoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateRepositoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateRepositoryResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateRepositoryCommand");
+var de_CreateRepositoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidTagParameterException":
+    case "com.amazonaws.ecr#InvalidTagParameterException":
+      throw await de_InvalidTagParameterExceptionRes(parsedOutput, context);
+    case "KmsException":
+    case "com.amazonaws.ecr#KmsException":
+      throw await de_KmsExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.ecr#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RepositoryAlreadyExistsException":
+    case "com.amazonaws.ecr#RepositoryAlreadyExistsException":
+      throw await de_RepositoryAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.ecr#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateRepositoryCommandError");
+var de_DeleteLifecyclePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteLifecyclePolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteLifecyclePolicyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteLifecyclePolicyCommand");
+var de_DeleteLifecyclePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LifecyclePolicyNotFoundException":
+    case "com.amazonaws.ecr#LifecyclePolicyNotFoundException":
+      throw await de_LifecyclePolicyNotFoundExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteLifecyclePolicyCommandError");
+var de_DeletePullThroughCacheRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeletePullThroughCacheRuleCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeletePullThroughCacheRuleResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeletePullThroughCacheRuleCommand");
+var de_DeletePullThroughCacheRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "PullThroughCacheRuleNotFoundException":
+    case "com.amazonaws.ecr#PullThroughCacheRuleNotFoundException":
+      throw await de_PullThroughCacheRuleNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeletePullThroughCacheRuleCommandError");
+var de_DeleteRegistryPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteRegistryPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteRegistryPolicyCommand");
+var de_DeleteRegistryPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RegistryPolicyNotFoundException":
+    case "com.amazonaws.ecr#RegistryPolicyNotFoundException":
+      throw await de_RegistryPolicyNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRegistryPolicyCommandError");
+var de_DeleteRepositoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteRepositoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteRepositoryResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteRepositoryCommand");
+var de_DeleteRepositoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "KmsException":
+    case "com.amazonaws.ecr#KmsException":
+      throw await de_KmsExceptionRes(parsedOutput, context);
+    case "RepositoryNotEmptyException":
+    case "com.amazonaws.ecr#RepositoryNotEmptyException":
+      throw await de_RepositoryNotEmptyExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRepositoryCommandError");
+var de_DeleteRepositoryPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteRepositoryPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteRepositoryPolicyCommand");
+var de_DeleteRepositoryPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "RepositoryPolicyNotFoundException":
+    case "com.amazonaws.ecr#RepositoryPolicyNotFoundException":
+      throw await de_RepositoryPolicyNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRepositoryPolicyCommandError");
+var de_DescribeImageReplicationStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeImageReplicationStatusCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeImageReplicationStatusCommand");
+var de_DescribeImageReplicationStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ImageNotFoundException":
+    case "com.amazonaws.ecr#ImageNotFoundException":
+      throw await de_ImageNotFoundExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeImageReplicationStatusCommandError");
+var de_DescribeImagesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeImagesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeImagesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeImagesCommand");
+var de_DescribeImagesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ImageNotFoundException":
+    case "com.amazonaws.ecr#ImageNotFoundException":
+      throw await de_ImageNotFoundExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeImagesCommandError");
+var de_DescribeImageScanFindingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeImageScanFindingsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeImageScanFindingsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeImageScanFindingsCommand");
+var de_DescribeImageScanFindingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ImageNotFoundException":
+    case "com.amazonaws.ecr#ImageNotFoundException":
+      throw await de_ImageNotFoundExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ScanNotFoundException":
+    case "com.amazonaws.ecr#ScanNotFoundException":
+      throw await de_ScanNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeImageScanFindingsCommandError");
+var de_DescribePullThroughCacheRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribePullThroughCacheRulesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribePullThroughCacheRulesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribePullThroughCacheRulesCommand");
+var de_DescribePullThroughCacheRulesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "PullThroughCacheRuleNotFoundException":
+    case "com.amazonaws.ecr#PullThroughCacheRuleNotFoundException":
+      throw await de_PullThroughCacheRuleNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribePullThroughCacheRulesCommandError");
+var de_DescribeRegistryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeRegistryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeRegistryCommand");
+var de_DescribeRegistryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeRegistryCommandError");
+var de_DescribeRepositoriesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeRepositoriesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeRepositoriesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeRepositoriesCommand");
+var de_DescribeRepositoriesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeRepositoriesCommandError");
+var de_GetAuthorizationTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAuthorizationTokenCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetAuthorizationTokenResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAuthorizationTokenCommand");
+var de_GetAuthorizationTokenCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAuthorizationTokenCommandError");
+var de_GetDownloadUrlForLayerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetDownloadUrlForLayerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetDownloadUrlForLayerCommand");
+var de_GetDownloadUrlForLayerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LayerInaccessibleException":
+    case "com.amazonaws.ecr#LayerInaccessibleException":
+      throw await de_LayerInaccessibleExceptionRes(parsedOutput, context);
+    case "LayersNotFoundException":
+    case "com.amazonaws.ecr#LayersNotFoundException":
+      throw await de_LayersNotFoundExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "UnableToGetUpstreamLayerException":
+    case "com.amazonaws.ecr#UnableToGetUpstreamLayerException":
+      throw await de_UnableToGetUpstreamLayerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDownloadUrlForLayerCommandError");
+var de_GetLifecyclePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetLifecyclePolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetLifecyclePolicyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetLifecyclePolicyCommand");
+var de_GetLifecyclePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LifecyclePolicyNotFoundException":
+    case "com.amazonaws.ecr#LifecyclePolicyNotFoundException":
+      throw await de_LifecyclePolicyNotFoundExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLifecyclePolicyCommandError");
+var de_GetLifecyclePolicyPreviewCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetLifecyclePolicyPreviewCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetLifecyclePolicyPreviewResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetLifecyclePolicyPreviewCommand");
+var de_GetLifecyclePolicyPreviewCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LifecyclePolicyPreviewNotFoundException":
+    case "com.amazonaws.ecr#LifecyclePolicyPreviewNotFoundException":
+      throw await de_LifecyclePolicyPreviewNotFoundExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetLifecyclePolicyPreviewCommandError");
+var de_GetRegistryPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetRegistryPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetRegistryPolicyCommand");
+var de_GetRegistryPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RegistryPolicyNotFoundException":
+    case "com.amazonaws.ecr#RegistryPolicyNotFoundException":
+      throw await de_RegistryPolicyNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetRegistryPolicyCommandError");
+var de_GetRegistryScanningConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetRegistryScanningConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetRegistryScanningConfigurationCommand");
+var de_GetRegistryScanningConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetRegistryScanningConfigurationCommandError");
+var de_GetRepositoryPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetRepositoryPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetRepositoryPolicyCommand");
+var de_GetRepositoryPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "RepositoryPolicyNotFoundException":
+    case "com.amazonaws.ecr#RepositoryPolicyNotFoundException":
+      throw await de_RepositoryPolicyNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetRepositoryPolicyCommandError");
+var de_InitiateLayerUploadCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_InitiateLayerUploadCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_InitiateLayerUploadCommand");
+var de_InitiateLayerUploadCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "KmsException":
+    case "com.amazonaws.ecr#KmsException":
+      throw await de_KmsExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_InitiateLayerUploadCommandError");
+var de_ListImagesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListImagesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListImagesCommand");
+var de_ListImagesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListImagesCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_PutImageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutImageCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutImageCommand");
+var de_PutImageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ImageAlreadyExistsException":
+    case "com.amazonaws.ecr#ImageAlreadyExistsException":
+      throw await de_ImageAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ImageDigestDoesNotMatchException":
+    case "com.amazonaws.ecr#ImageDigestDoesNotMatchException":
+      throw await de_ImageDigestDoesNotMatchExceptionRes(parsedOutput, context);
+    case "ImageTagAlreadyExistsException":
+    case "com.amazonaws.ecr#ImageTagAlreadyExistsException":
+      throw await de_ImageTagAlreadyExistsExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "KmsException":
+    case "com.amazonaws.ecr#KmsException":
+      throw await de_KmsExceptionRes(parsedOutput, context);
+    case "LayersNotFoundException":
+    case "com.amazonaws.ecr#LayersNotFoundException":
+      throw await de_LayersNotFoundExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.ecr#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ReferencedImagesNotFoundException":
+    case "com.amazonaws.ecr#ReferencedImagesNotFoundException":
+      throw await de_ReferencedImagesNotFoundExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutImageCommandError");
+var de_PutImageScanningConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutImageScanningConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutImageScanningConfigurationCommand");
+var de_PutImageScanningConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutImageScanningConfigurationCommandError");
+var de_PutImageTagMutabilityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutImageTagMutabilityCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutImageTagMutabilityCommand");
+var de_PutImageTagMutabilityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutImageTagMutabilityCommandError");
+var de_PutLifecyclePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutLifecyclePolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutLifecyclePolicyCommand");
+var de_PutLifecyclePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutLifecyclePolicyCommandError");
+var de_PutRegistryPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutRegistryPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutRegistryPolicyCommand");
+var de_PutRegistryPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutRegistryPolicyCommandError");
+var de_PutRegistryScanningConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutRegistryScanningConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutRegistryScanningConfigurationCommand");
+var de_PutRegistryScanningConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutRegistryScanningConfigurationCommandError");
+var de_PutReplicationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutReplicationConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutReplicationConfigurationCommand");
+var de_PutReplicationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutReplicationConfigurationCommandError");
+var de_SetRepositoryPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SetRepositoryPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SetRepositoryPolicyCommand");
+var de_SetRepositoryPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SetRepositoryPolicyCommandError");
+var de_StartImageScanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartImageScanCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartImageScanCommand");
+var de_StartImageScanCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ImageNotFoundException":
+    case "com.amazonaws.ecr#ImageNotFoundException":
+      throw await de_ImageNotFoundExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.ecr#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "UnsupportedImageTypeException":
+    case "com.amazonaws.ecr#UnsupportedImageTypeException":
+      throw await de_UnsupportedImageTypeExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartImageScanCommandError");
+var de_StartLifecyclePolicyPreviewCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartLifecyclePolicyPreviewCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartLifecyclePolicyPreviewCommand");
+var de_StartLifecyclePolicyPreviewCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "LifecyclePolicyNotFoundException":
+    case "com.amazonaws.ecr#LifecyclePolicyNotFoundException":
+      throw await de_LifecyclePolicyNotFoundExceptionRes(parsedOutput, context);
+    case "LifecyclePolicyPreviewInProgressException":
+    case "com.amazonaws.ecr#LifecyclePolicyPreviewInProgressException":
+      throw await de_LifecyclePolicyPreviewInProgressExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartLifecyclePolicyPreviewCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidTagParameterException":
+    case "com.amazonaws.ecr#InvalidTagParameterException":
+      throw await de_InvalidTagParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.ecr#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "InvalidTagParameterException":
+    case "com.amazonaws.ecr#InvalidTagParameterException":
+      throw await de_InvalidTagParameterExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.ecr#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdatePullThroughCacheRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdatePullThroughCacheRuleCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdatePullThroughCacheRuleResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdatePullThroughCacheRuleCommand");
+var de_UpdatePullThroughCacheRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "PullThroughCacheRuleNotFoundException":
+    case "com.amazonaws.ecr#PullThroughCacheRuleNotFoundException":
+      throw await de_PullThroughCacheRuleNotFoundExceptionRes(parsedOutput, context);
+    case "SecretNotFoundException":
+    case "com.amazonaws.ecr#SecretNotFoundException":
+      throw await de_SecretNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "UnableToAccessSecretException":
+    case "com.amazonaws.ecr#UnableToAccessSecretException":
+      throw await de_UnableToAccessSecretExceptionRes(parsedOutput, context);
+    case "UnableToDecryptSecretValueException":
+    case "com.amazonaws.ecr#UnableToDecryptSecretValueException":
+      throw await de_UnableToDecryptSecretValueExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdatePullThroughCacheRuleCommandError");
+var de_UploadLayerPartCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UploadLayerPartCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UploadLayerPartCommand");
+var de_UploadLayerPartCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidLayerPartException":
+    case "com.amazonaws.ecr#InvalidLayerPartException":
+      throw await de_InvalidLayerPartExceptionRes(parsedOutput, context);
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "KmsException":
+    case "com.amazonaws.ecr#KmsException":
+      throw await de_KmsExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.ecr#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "RepositoryNotFoundException":
+    case "com.amazonaws.ecr#RepositoryNotFoundException":
+      throw await de_RepositoryNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "UploadNotFoundException":
+    case "com.amazonaws.ecr#UploadNotFoundException":
+      throw await de_UploadNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UploadLayerPartCommandError");
+var de_ValidatePullThroughCacheRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ValidatePullThroughCacheRuleCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ValidatePullThroughCacheRuleCommand");
+var de_ValidatePullThroughCacheRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterException":
+    case "com.amazonaws.ecr#InvalidParameterException":
+      throw await de_InvalidParameterExceptionRes(parsedOutput, context);
+    case "PullThroughCacheRuleNotFoundException":
+    case "com.amazonaws.ecr#PullThroughCacheRuleNotFoundException":
+      throw await de_PullThroughCacheRuleNotFoundExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.ecr#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ValidatePullThroughCacheRuleCommandError");
+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_KmsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new KmsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_KmsExceptionRes");
+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_LayerInaccessibleExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LayerInaccessibleException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LayerInaccessibleExceptionRes");
+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_LifecyclePolicyNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LifecyclePolicyNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LifecyclePolicyNotFoundExceptionRes");
+var de_LifecyclePolicyPreviewInProgressExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LifecyclePolicyPreviewInProgressException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LifecyclePolicyPreviewInProgressExceptionRes");
+var de_LifecyclePolicyPreviewNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LifecyclePolicyPreviewNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LifecyclePolicyPreviewNotFoundExceptionRes");
+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_PullThroughCacheRuleAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new PullThroughCacheRuleAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PullThroughCacheRuleAlreadyExistsExceptionRes");
+var de_PullThroughCacheRuleNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new PullThroughCacheRuleNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PullThroughCacheRuleNotFoundExceptionRes");
+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_RegistryPolicyNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new RegistryPolicyNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_RegistryPolicyNotFoundExceptionRes");
+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_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_ScanNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ScanNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ScanNotFoundExceptionRes");
+var de_SecretNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new SecretNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_SecretNotFoundExceptionRes");
+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_UnableToAccessSecretExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnableToAccessSecretException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnableToAccessSecretExceptionRes");
+var de_UnableToDecryptSecretValueExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnableToDecryptSecretValueException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnableToDecryptSecretValueExceptionRes");
+var de_UnableToGetUpstreamImageExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnableToGetUpstreamImageException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnableToGetUpstreamImageExceptionRes");
+var de_UnableToGetUpstreamLayerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnableToGetUpstreamLayerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnableToGetUpstreamLayerExceptionRes");
+var de_UnsupportedImageTypeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnsupportedImageTypeException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnsupportedImageTypeExceptionRes");
+var de_UnsupportedUpstreamRegistryExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnsupportedUpstreamRegistryException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnsupportedUpstreamRegistryExceptionRes");
+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 de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ValidationExceptionRes");
+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: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    proxyEndpoint: import_smithy_client.expectString
+  });
+}, "de_AuthorizationData");
+var de_AuthorizationDataList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AuthorizationData(entry, context);
+  });
+  return retVal;
+}, "de_AuthorizationDataList");
+var de_AwsEcrContainerImageDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    architecture: import_smithy_client.expectString,
+    author: import_smithy_client.expectString,
+    imageHash: import_smithy_client.expectString,
+    imageTags: import_smithy_client._json,
+    platform: import_smithy_client.expectString,
+    pushedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    registry: import_smithy_client.expectString,
+    repositoryName: import_smithy_client.expectString
+  });
+}, "de_AwsEcrContainerImageDetails");
+var de_CreatePullThroughCacheRuleResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    credentialArn: import_smithy_client.expectString,
+    ecrRepositoryPrefix: import_smithy_client.expectString,
+    registryId: import_smithy_client.expectString,
+    upstreamRegistry: import_smithy_client.expectString,
+    upstreamRegistryUrl: import_smithy_client.expectString
+  });
+}, "de_CreatePullThroughCacheRuleResponse");
+var de_CreateRepositoryResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    repository: (_) => de_Repository(_, context)
+  });
+}, "de_CreateRepositoryResponse");
+var de_CvssScore = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    baseScore: import_smithy_client.limitedParseDouble,
+    scoringVector: import_smithy_client.expectString,
+    source: import_smithy_client.expectString,
+    version: import_smithy_client.expectString
+  });
+}, "de_CvssScore");
+var de_CvssScoreDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    adjustments: import_smithy_client._json,
+    score: import_smithy_client.limitedParseDouble,
+    scoreSource: import_smithy_client.expectString,
+    scoringVector: import_smithy_client.expectString,
+    version: import_smithy_client.expectString
+  });
+}, "de_CvssScoreDetails");
+var de_CvssScoreList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CvssScore(entry, context);
+  });
+  return retVal;
+}, "de_CvssScoreList");
+var de_DeleteLifecyclePolicyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    lastEvaluatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lifecyclePolicyText: import_smithy_client.expectString,
+    registryId: import_smithy_client.expectString,
+    repositoryName: import_smithy_client.expectString
+  });
+}, "de_DeleteLifecyclePolicyResponse");
+var de_DeletePullThroughCacheRuleResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    credentialArn: import_smithy_client.expectString,
+    ecrRepositoryPrefix: import_smithy_client.expectString,
+    registryId: import_smithy_client.expectString,
+    upstreamRegistryUrl: import_smithy_client.expectString
+  });
+}, "de_DeletePullThroughCacheRuleResponse");
+var de_DeleteRepositoryResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    repository: (_) => de_Repository(_, context)
+  });
+}, "de_DeleteRepositoryResponse");
+var de_DescribeImageScanFindingsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    imageId: import_smithy_client._json,
+    imageScanFindings: (_) => de_ImageScanFindings(_, context),
+    imageScanStatus: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString,
+    registryId: import_smithy_client.expectString,
+    repositoryName: import_smithy_client.expectString
+  });
+}, "de_DescribeImageScanFindingsResponse");
+var de_DescribeImagesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    imageDetails: (_) => de_ImageDetailList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_DescribeImagesResponse");
+var de_DescribePullThroughCacheRulesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    pullThroughCacheRules: (_) => de_PullThroughCacheRuleList(_, context)
+  });
+}, "de_DescribePullThroughCacheRulesResponse");
+var de_DescribeRepositoriesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    repositories: (_) => de_RepositoryList(_, context)
+  });
+}, "de_DescribeRepositoriesResponse");
+var de_EnhancedImageScanFinding = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    awsAccountId: import_smithy_client.expectString,
+    description: import_smithy_client.expectString,
+    findingArn: import_smithy_client.expectString,
+    firstObservedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastObservedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    packageVulnerabilityDetails: (_) => de_PackageVulnerabilityDetails(_, context),
+    remediation: import_smithy_client._json,
+    resources: (_) => de_ResourceList(_, context),
+    score: import_smithy_client.limitedParseDouble,
+    scoreDetails: (_) => de_ScoreDetails(_, context),
+    severity: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    title: import_smithy_client.expectString,
+    type: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_EnhancedImageScanFinding");
+var de_EnhancedImageScanFindingList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_EnhancedImageScanFinding(entry, context);
+  });
+  return retVal;
+}, "de_EnhancedImageScanFindingList");
+var de_GetAuthorizationTokenResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    authorizationData: (_) => de_AuthorizationDataList(_, context)
+  });
+}, "de_GetAuthorizationTokenResponse");
+var de_GetLifecyclePolicyPreviewResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    lifecyclePolicyText: import_smithy_client.expectString,
+    nextToken: import_smithy_client.expectString,
+    previewResults: (_) => de_LifecyclePolicyPreviewResultList(_, context),
+    registryId: import_smithy_client.expectString,
+    repositoryName: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    summary: import_smithy_client._json
+  });
+}, "de_GetLifecyclePolicyPreviewResponse");
+var de_GetLifecyclePolicyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    lastEvaluatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lifecyclePolicyText: import_smithy_client.expectString,
+    registryId: import_smithy_client.expectString,
+    repositoryName: import_smithy_client.expectString
+  });
+}, "de_GetLifecyclePolicyResponse");
+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: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    imageScanFindingsSummary: (_) => de_ImageScanFindingsSummary(_, context),
+    imageScanStatus: import_smithy_client._json,
+    imageSizeInBytes: import_smithy_client.expectLong,
+    imageTags: import_smithy_client._json,
+    lastRecordedPullTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    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_ImageScanFindings = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    enhancedFindings: (_) => de_EnhancedImageScanFindingList(_, context),
+    findingSeverityCounts: import_smithy_client._json,
+    findings: import_smithy_client._json,
+    imageScanCompletedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    vulnerabilitySourceUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_ImageScanFindings");
+var de_ImageScanFindingsSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    findingSeverityCounts: import_smithy_client._json,
+    imageScanCompletedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    vulnerabilitySourceUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_ImageScanFindingsSummary");
+var de_LifecyclePolicyPreviewResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    action: import_smithy_client._json,
+    appliedRulePriority: import_smithy_client.expectInt32,
+    imageDigest: import_smithy_client.expectString,
+    imagePushedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    imageTags: import_smithy_client._json
+  });
+}, "de_LifecyclePolicyPreviewResult");
+var de_LifecyclePolicyPreviewResultList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LifecyclePolicyPreviewResult(entry, context);
+  });
+  return retVal;
+}, "de_LifecyclePolicyPreviewResultList");
+var de_PackageVulnerabilityDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    cvss: (_) => de_CvssScoreList(_, context),
+    referenceUrls: import_smithy_client._json,
+    relatedVulnerabilities: import_smithy_client._json,
+    source: import_smithy_client.expectString,
+    sourceUrl: import_smithy_client.expectString,
+    vendorCreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    vendorSeverity: import_smithy_client.expectString,
+    vendorUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    vulnerabilityId: import_smithy_client.expectString,
+    vulnerablePackages: import_smithy_client._json
+  });
+}, "de_PackageVulnerabilityDetails");
+var de_PullThroughCacheRule = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    credentialArn: import_smithy_client.expectString,
+    ecrRepositoryPrefix: import_smithy_client.expectString,
+    registryId: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    upstreamRegistry: import_smithy_client.expectString,
+    upstreamRegistryUrl: import_smithy_client.expectString
+  });
+}, "de_PullThroughCacheRule");
+var de_PullThroughCacheRuleList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_PullThroughCacheRule(entry, context);
+  });
+  return retVal;
+}, "de_PullThroughCacheRuleList");
+var de_Repository = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    encryptionConfiguration: import_smithy_client._json,
+    imageScanningConfiguration: import_smithy_client._json,
+    imageTagMutability: import_smithy_client.expectString,
+    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 de_Resource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    details: (_) => de_ResourceDetails(_, context),
+    id: import_smithy_client.expectString,
+    tags: import_smithy_client._json,
+    type: import_smithy_client.expectString
+  });
+}, "de_Resource");
+var de_ResourceDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    awsEcrContainerImage: (_) => de_AwsEcrContainerImageDetails(_, context)
+  });
+}, "de_ResourceDetails");
+var de_ResourceList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Resource(entry, context);
+  });
+  return retVal;
+}, "de_ResourceList");
+var de_ScoreDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    cvss: (_) => de_CvssScoreDetails(_, context)
+  });
+}, "de_ScoreDetails");
+var de_UpdatePullThroughCacheRuleResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    credentialArn: import_smithy_client.expectString,
+    ecrRepositoryPrefix: import_smithy_client.expectString,
+    registryId: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_UpdatePullThroughCacheRuleResponse");
+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 collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(ECRServiceException);
+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": `AmazonEC2ContainerRegistry_V20150921.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/BatchCheckLayerAvailabilityCommand.ts
+var _BatchCheckLayerAvailabilityCommand = class _BatchCheckLayerAvailabilityCommand 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("AmazonEC2ContainerRegistry_V20150921", "BatchCheckLayerAvailability", {}).n("ECRClient", "BatchCheckLayerAvailabilityCommand").f(void 0, void 0).ser(se_BatchCheckLayerAvailabilityCommand).de(de_BatchCheckLayerAvailabilityCommand).build() {
+};
+__name(_BatchCheckLayerAvailabilityCommand, "BatchCheckLayerAvailabilityCommand");
+var BatchCheckLayerAvailabilityCommand = _BatchCheckLayerAvailabilityCommand;
+
+// src/commands/BatchDeleteImageCommand.ts
+
+
+
+
+var _BatchDeleteImageCommand = class _BatchDeleteImageCommand 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("AmazonEC2ContainerRegistry_V20150921", "BatchDeleteImage", {}).n("ECRClient", "BatchDeleteImageCommand").f(void 0, void 0).ser(se_BatchDeleteImageCommand).de(de_BatchDeleteImageCommand).build() {
+};
+__name(_BatchDeleteImageCommand, "BatchDeleteImageCommand");
+var BatchDeleteImageCommand = _BatchDeleteImageCommand;
+
+// src/commands/BatchGetImageCommand.ts
+
+
+
+
+var _BatchGetImageCommand = class _BatchGetImageCommand 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("AmazonEC2ContainerRegistry_V20150921", "BatchGetImage", {}).n("ECRClient", "BatchGetImageCommand").f(void 0, void 0).ser(se_BatchGetImageCommand).de(de_BatchGetImageCommand).build() {
+};
+__name(_BatchGetImageCommand, "BatchGetImageCommand");
+var BatchGetImageCommand = _BatchGetImageCommand;
+
+// src/commands/BatchGetRepositoryScanningConfigurationCommand.ts
+
+
+
+
+var _BatchGetRepositoryScanningConfigurationCommand = class _BatchGetRepositoryScanningConfigurationCommand 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("AmazonEC2ContainerRegistry_V20150921", "BatchGetRepositoryScanningConfiguration", {}).n("ECRClient", "BatchGetRepositoryScanningConfigurationCommand").f(void 0, void 0).ser(se_BatchGetRepositoryScanningConfigurationCommand).de(de_BatchGetRepositoryScanningConfigurationCommand).build() {
+};
+__name(_BatchGetRepositoryScanningConfigurationCommand, "BatchGetRepositoryScanningConfigurationCommand");
+var BatchGetRepositoryScanningConfigurationCommand = _BatchGetRepositoryScanningConfigurationCommand;
+
+// src/commands/CompleteLayerUploadCommand.ts
+
+
+
+
+var _CompleteLayerUploadCommand = class _CompleteLayerUploadCommand 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("AmazonEC2ContainerRegistry_V20150921", "CompleteLayerUpload", {}).n("ECRClient", "CompleteLayerUploadCommand").f(void 0, void 0).ser(se_CompleteLayerUploadCommand).de(de_CompleteLayerUploadCommand).build() {
+};
+__name(_CompleteLayerUploadCommand, "CompleteLayerUploadCommand");
+var CompleteLayerUploadCommand = _CompleteLayerUploadCommand;
+
+// src/commands/CreatePullThroughCacheRuleCommand.ts
+
+
+
+
+var _CreatePullThroughCacheRuleCommand = class _CreatePullThroughCacheRuleCommand 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("AmazonEC2ContainerRegistry_V20150921", "CreatePullThroughCacheRule", {}).n("ECRClient", "CreatePullThroughCacheRuleCommand").f(void 0, void 0).ser(se_CreatePullThroughCacheRuleCommand).de(de_CreatePullThroughCacheRuleCommand).build() {
+};
+__name(_CreatePullThroughCacheRuleCommand, "CreatePullThroughCacheRuleCommand");
+var CreatePullThroughCacheRuleCommand = _CreatePullThroughCacheRuleCommand;
+
+// src/commands/CreateRepositoryCommand.ts
+
+
+
+
+var _CreateRepositoryCommand = class _CreateRepositoryCommand 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("AmazonEC2ContainerRegistry_V20150921", "CreateRepository", {}).n("ECRClient", "CreateRepositoryCommand").f(void 0, void 0).ser(se_CreateRepositoryCommand).de(de_CreateRepositoryCommand).build() {
+};
+__name(_CreateRepositoryCommand, "CreateRepositoryCommand");
+var CreateRepositoryCommand = _CreateRepositoryCommand;
+
+// src/commands/DeleteLifecyclePolicyCommand.ts
+
+
+
+
+var _DeleteLifecyclePolicyCommand = class _DeleteLifecyclePolicyCommand 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("AmazonEC2ContainerRegistry_V20150921", "DeleteLifecyclePolicy", {}).n("ECRClient", "DeleteLifecyclePolicyCommand").f(void 0, void 0).ser(se_DeleteLifecyclePolicyCommand).de(de_DeleteLifecyclePolicyCommand).build() {
+};
+__name(_DeleteLifecyclePolicyCommand, "DeleteLifecyclePolicyCommand");
+var DeleteLifecyclePolicyCommand = _DeleteLifecyclePolicyCommand;
+
+// src/commands/DeletePullThroughCacheRuleCommand.ts
+
+
+
+
+var _DeletePullThroughCacheRuleCommand = class _DeletePullThroughCacheRuleCommand 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("AmazonEC2ContainerRegistry_V20150921", "DeletePullThroughCacheRule", {}).n("ECRClient", "DeletePullThroughCacheRuleCommand").f(void 0, void 0).ser(se_DeletePullThroughCacheRuleCommand).de(de_DeletePullThroughCacheRuleCommand).build() {
+};
+__name(_DeletePullThroughCacheRuleCommand, "DeletePullThroughCacheRuleCommand");
+var DeletePullThroughCacheRuleCommand = _DeletePullThroughCacheRuleCommand;
+
+// src/commands/DeleteRegistryPolicyCommand.ts
+
+
+
+
+var _DeleteRegistryPolicyCommand = class _DeleteRegistryPolicyCommand 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("AmazonEC2ContainerRegistry_V20150921", "DeleteRegistryPolicy", {}).n("ECRClient", "DeleteRegistryPolicyCommand").f(void 0, void 0).ser(se_DeleteRegistryPolicyCommand).de(de_DeleteRegistryPolicyCommand).build() {
+};
+__name(_DeleteRegistryPolicyCommand, "DeleteRegistryPolicyCommand");
+var DeleteRegistryPolicyCommand = _DeleteRegistryPolicyCommand;
+
+// src/commands/DeleteRepositoryCommand.ts
+
+
+
+
+var _DeleteRepositoryCommand = class _DeleteRepositoryCommand 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("AmazonEC2ContainerRegistry_V20150921", "DeleteRepository", {}).n("ECRClient", "DeleteRepositoryCommand").f(void 0, void 0).ser(se_DeleteRepositoryCommand).de(de_DeleteRepositoryCommand).build() {
+};
+__name(_DeleteRepositoryCommand, "DeleteRepositoryCommand");
+var DeleteRepositoryCommand = _DeleteRepositoryCommand;
+
+// src/commands/DeleteRepositoryPolicyCommand.ts
+
+
+
+
+var _DeleteRepositoryPolicyCommand = class _DeleteRepositoryPolicyCommand 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("AmazonEC2ContainerRegistry_V20150921", "DeleteRepositoryPolicy", {}).n("ECRClient", "DeleteRepositoryPolicyCommand").f(void 0, void 0).ser(se_DeleteRepositoryPolicyCommand).de(de_DeleteRepositoryPolicyCommand).build() {
+};
+__name(_DeleteRepositoryPolicyCommand, "DeleteRepositoryPolicyCommand");
+var DeleteRepositoryPolicyCommand = _DeleteRepositoryPolicyCommand;
+
+// src/commands/DescribeImageReplicationStatusCommand.ts
+
+
+
+
+var _DescribeImageReplicationStatusCommand = class _DescribeImageReplicationStatusCommand 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("AmazonEC2ContainerRegistry_V20150921", "DescribeImageReplicationStatus", {}).n("ECRClient", "DescribeImageReplicationStatusCommand").f(void 0, void 0).ser(se_DescribeImageReplicationStatusCommand).de(de_DescribeImageReplicationStatusCommand).build() {
+};
+__name(_DescribeImageReplicationStatusCommand, "DescribeImageReplicationStatusCommand");
+var DescribeImageReplicationStatusCommand = _DescribeImageReplicationStatusCommand;
+
+// src/commands/DescribeImageScanFindingsCommand.ts
+
+
+
+
+var _DescribeImageScanFindingsCommand = class _DescribeImageScanFindingsCommand 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("AmazonEC2ContainerRegistry_V20150921", "DescribeImageScanFindings", {}).n("ECRClient", "DescribeImageScanFindingsCommand").f(void 0, void 0).ser(se_DescribeImageScanFindingsCommand).de(de_DescribeImageScanFindingsCommand).build() {
+};
+__name(_DescribeImageScanFindingsCommand, "DescribeImageScanFindingsCommand");
+var DescribeImageScanFindingsCommand = _DescribeImageScanFindingsCommand;
+
+// src/commands/DescribeImagesCommand.ts
+
+
+
+
+var _DescribeImagesCommand = class _DescribeImagesCommand 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("AmazonEC2ContainerRegistry_V20150921", "DescribeImages", {}).n("ECRClient", "DescribeImagesCommand").f(void 0, void 0).ser(se_DescribeImagesCommand).de(de_DescribeImagesCommand).build() {
+};
+__name(_DescribeImagesCommand, "DescribeImagesCommand");
+var DescribeImagesCommand = _DescribeImagesCommand;
+
+// src/commands/DescribePullThroughCacheRulesCommand.ts
+
+
+
+
+var _DescribePullThroughCacheRulesCommand = class _DescribePullThroughCacheRulesCommand 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("AmazonEC2ContainerRegistry_V20150921", "DescribePullThroughCacheRules", {}).n("ECRClient", "DescribePullThroughCacheRulesCommand").f(void 0, void 0).ser(se_DescribePullThroughCacheRulesCommand).de(de_DescribePullThroughCacheRulesCommand).build() {
+};
+__name(_DescribePullThroughCacheRulesCommand, "DescribePullThroughCacheRulesCommand");
+var DescribePullThroughCacheRulesCommand = _DescribePullThroughCacheRulesCommand;
+
+// src/commands/DescribeRegistryCommand.ts
+
+
+
+
+var _DescribeRegistryCommand = class _DescribeRegistryCommand 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("AmazonEC2ContainerRegistry_V20150921", "DescribeRegistry", {}).n("ECRClient", "DescribeRegistryCommand").f(void 0, void 0).ser(se_DescribeRegistryCommand).de(de_DescribeRegistryCommand).build() {
+};
+__name(_DescribeRegistryCommand, "DescribeRegistryCommand");
+var DescribeRegistryCommand = _DescribeRegistryCommand;
+
+// src/commands/DescribeRepositoriesCommand.ts
+
+
+
+
+var _DescribeRepositoriesCommand = class _DescribeRepositoriesCommand 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("AmazonEC2ContainerRegistry_V20150921", "DescribeRepositories", {}).n("ECRClient", "DescribeRepositoriesCommand").f(void 0, void 0).ser(se_DescribeRepositoriesCommand).de(de_DescribeRepositoriesCommand).build() {
+};
+__name(_DescribeRepositoriesCommand, "DescribeRepositoriesCommand");
+var DescribeRepositoriesCommand = _DescribeRepositoriesCommand;
+
+// src/commands/GetAuthorizationTokenCommand.ts
+
+
+
+
+var _GetAuthorizationTokenCommand = class _GetAuthorizationTokenCommand 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("AmazonEC2ContainerRegistry_V20150921", "GetAuthorizationToken", {}).n("ECRClient", "GetAuthorizationTokenCommand").f(void 0, void 0).ser(se_GetAuthorizationTokenCommand).de(de_GetAuthorizationTokenCommand).build() {
+};
+__name(_GetAuthorizationTokenCommand, "GetAuthorizationTokenCommand");
+var GetAuthorizationTokenCommand = _GetAuthorizationTokenCommand;
+
+// src/commands/GetDownloadUrlForLayerCommand.ts
+
+
+
+
+var _GetDownloadUrlForLayerCommand = class _GetDownloadUrlForLayerCommand 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("AmazonEC2ContainerRegistry_V20150921", "GetDownloadUrlForLayer", {}).n("ECRClient", "GetDownloadUrlForLayerCommand").f(void 0, void 0).ser(se_GetDownloadUrlForLayerCommand).de(de_GetDownloadUrlForLayerCommand).build() {
+};
+__name(_GetDownloadUrlForLayerCommand, "GetDownloadUrlForLayerCommand");
+var GetDownloadUrlForLayerCommand = _GetDownloadUrlForLayerCommand;
+
+// src/commands/GetLifecyclePolicyCommand.ts
+
+
+
+
+var _GetLifecyclePolicyCommand = class _GetLifecyclePolicyCommand 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("AmazonEC2ContainerRegistry_V20150921", "GetLifecyclePolicy", {}).n("ECRClient", "GetLifecyclePolicyCommand").f(void 0, void 0).ser(se_GetLifecyclePolicyCommand).de(de_GetLifecyclePolicyCommand).build() {
+};
+__name(_GetLifecyclePolicyCommand, "GetLifecyclePolicyCommand");
+var GetLifecyclePolicyCommand = _GetLifecyclePolicyCommand;
+
+// src/commands/GetLifecyclePolicyPreviewCommand.ts
+
+
+
+
+var _GetLifecyclePolicyPreviewCommand = class _GetLifecyclePolicyPreviewCommand 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("AmazonEC2ContainerRegistry_V20150921", "GetLifecyclePolicyPreview", {}).n("ECRClient", "GetLifecyclePolicyPreviewCommand").f(void 0, void 0).ser(se_GetLifecyclePolicyPreviewCommand).de(de_GetLifecyclePolicyPreviewCommand).build() {
+};
+__name(_GetLifecyclePolicyPreviewCommand, "GetLifecyclePolicyPreviewCommand");
+var GetLifecyclePolicyPreviewCommand = _GetLifecyclePolicyPreviewCommand;
+
+// src/commands/GetRegistryPolicyCommand.ts
+
+
+
+
+var _GetRegistryPolicyCommand = class _GetRegistryPolicyCommand 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("AmazonEC2ContainerRegistry_V20150921", "GetRegistryPolicy", {}).n("ECRClient", "GetRegistryPolicyCommand").f(void 0, void 0).ser(se_GetRegistryPolicyCommand).de(de_GetRegistryPolicyCommand).build() {
+};
+__name(_GetRegistryPolicyCommand, "GetRegistryPolicyCommand");
+var GetRegistryPolicyCommand = _GetRegistryPolicyCommand;
+
+// src/commands/GetRegistryScanningConfigurationCommand.ts
+
+
+
+
+var _GetRegistryScanningConfigurationCommand = class _GetRegistryScanningConfigurationCommand 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("AmazonEC2ContainerRegistry_V20150921", "GetRegistryScanningConfiguration", {}).n("ECRClient", "GetRegistryScanningConfigurationCommand").f(void 0, void 0).ser(se_GetRegistryScanningConfigurationCommand).de(de_GetRegistryScanningConfigurationCommand).build() {
+};
+__name(_GetRegistryScanningConfigurationCommand, "GetRegistryScanningConfigurationCommand");
+var GetRegistryScanningConfigurationCommand = _GetRegistryScanningConfigurationCommand;
+
+// src/commands/GetRepositoryPolicyCommand.ts
+
+
+
+
+var _GetRepositoryPolicyCommand = class _GetRepositoryPolicyCommand 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("AmazonEC2ContainerRegistry_V20150921", "GetRepositoryPolicy", {}).n("ECRClient", "GetRepositoryPolicyCommand").f(void 0, void 0).ser(se_GetRepositoryPolicyCommand).de(de_GetRepositoryPolicyCommand).build() {
+};
+__name(_GetRepositoryPolicyCommand, "GetRepositoryPolicyCommand");
+var GetRepositoryPolicyCommand = _GetRepositoryPolicyCommand;
+
+// src/commands/InitiateLayerUploadCommand.ts
+
+
+
+
+var _InitiateLayerUploadCommand = class _InitiateLayerUploadCommand 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("AmazonEC2ContainerRegistry_V20150921", "InitiateLayerUpload", {}).n("ECRClient", "InitiateLayerUploadCommand").f(void 0, void 0).ser(se_InitiateLayerUploadCommand).de(de_InitiateLayerUploadCommand).build() {
+};
+__name(_InitiateLayerUploadCommand, "InitiateLayerUploadCommand");
+var InitiateLayerUploadCommand = _InitiateLayerUploadCommand;
+
+// src/commands/ListImagesCommand.ts
+
+
+
+
+var _ListImagesCommand = class _ListImagesCommand 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("AmazonEC2ContainerRegistry_V20150921", "ListImages", {}).n("ECRClient", "ListImagesCommand").f(void 0, void 0).ser(se_ListImagesCommand).de(de_ListImagesCommand).build() {
+};
+__name(_ListImagesCommand, "ListImagesCommand");
+var ListImagesCommand = _ListImagesCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand 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("AmazonEC2ContainerRegistry_V20150921", "ListTagsForResource", {}).n("ECRClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/PutImageCommand.ts
+
+
+
+
+var _PutImageCommand = class _PutImageCommand 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("AmazonEC2ContainerRegistry_V20150921", "PutImage", {}).n("ECRClient", "PutImageCommand").f(void 0, void 0).ser(se_PutImageCommand).de(de_PutImageCommand).build() {
+};
+__name(_PutImageCommand, "PutImageCommand");
+var PutImageCommand = _PutImageCommand;
+
+// src/commands/PutImageScanningConfigurationCommand.ts
+
+
+
+
+var _PutImageScanningConfigurationCommand = class _PutImageScanningConfigurationCommand 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("AmazonEC2ContainerRegistry_V20150921", "PutImageScanningConfiguration", {}).n("ECRClient", "PutImageScanningConfigurationCommand").f(void 0, void 0).ser(se_PutImageScanningConfigurationCommand).de(de_PutImageScanningConfigurationCommand).build() {
+};
+__name(_PutImageScanningConfigurationCommand, "PutImageScanningConfigurationCommand");
+var PutImageScanningConfigurationCommand = _PutImageScanningConfigurationCommand;
+
+// src/commands/PutImageTagMutabilityCommand.ts
+
+
+
+
+var _PutImageTagMutabilityCommand = class _PutImageTagMutabilityCommand 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("AmazonEC2ContainerRegistry_V20150921", "PutImageTagMutability", {}).n("ECRClient", "PutImageTagMutabilityCommand").f(void 0, void 0).ser(se_PutImageTagMutabilityCommand).de(de_PutImageTagMutabilityCommand).build() {
+};
+__name(_PutImageTagMutabilityCommand, "PutImageTagMutabilityCommand");
+var PutImageTagMutabilityCommand = _PutImageTagMutabilityCommand;
+
+// src/commands/PutLifecyclePolicyCommand.ts
+
+
+
+
+var _PutLifecyclePolicyCommand = class _PutLifecyclePolicyCommand 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("AmazonEC2ContainerRegistry_V20150921", "PutLifecyclePolicy", {}).n("ECRClient", "PutLifecyclePolicyCommand").f(void 0, void 0).ser(se_PutLifecyclePolicyCommand).de(de_PutLifecyclePolicyCommand).build() {
+};
+__name(_PutLifecyclePolicyCommand, "PutLifecyclePolicyCommand");
+var PutLifecyclePolicyCommand = _PutLifecyclePolicyCommand;
+
+// src/commands/PutRegistryPolicyCommand.ts
+
+
+
+
+var _PutRegistryPolicyCommand = class _PutRegistryPolicyCommand 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("AmazonEC2ContainerRegistry_V20150921", "PutRegistryPolicy", {}).n("ECRClient", "PutRegistryPolicyCommand").f(void 0, void 0).ser(se_PutRegistryPolicyCommand).de(de_PutRegistryPolicyCommand).build() {
+};
+__name(_PutRegistryPolicyCommand, "PutRegistryPolicyCommand");
+var PutRegistryPolicyCommand = _PutRegistryPolicyCommand;
+
+// src/commands/PutRegistryScanningConfigurationCommand.ts
+
+
+
+
+var _PutRegistryScanningConfigurationCommand = class _PutRegistryScanningConfigurationCommand 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("AmazonEC2ContainerRegistry_V20150921", "PutRegistryScanningConfiguration", {}).n("ECRClient", "PutRegistryScanningConfigurationCommand").f(void 0, void 0).ser(se_PutRegistryScanningConfigurationCommand).de(de_PutRegistryScanningConfigurationCommand).build() {
+};
+__name(_PutRegistryScanningConfigurationCommand, "PutRegistryScanningConfigurationCommand");
+var PutRegistryScanningConfigurationCommand = _PutRegistryScanningConfigurationCommand;
+
+// src/commands/PutReplicationConfigurationCommand.ts
+
+
+
+
+var _PutReplicationConfigurationCommand = class _PutReplicationConfigurationCommand 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("AmazonEC2ContainerRegistry_V20150921", "PutReplicationConfiguration", {}).n("ECRClient", "PutReplicationConfigurationCommand").f(void 0, void 0).ser(se_PutReplicationConfigurationCommand).de(de_PutReplicationConfigurationCommand).build() {
+};
+__name(_PutReplicationConfigurationCommand, "PutReplicationConfigurationCommand");
+var PutReplicationConfigurationCommand = _PutReplicationConfigurationCommand;
+
+// src/commands/SetRepositoryPolicyCommand.ts
+
+
+
+
+var _SetRepositoryPolicyCommand = class _SetRepositoryPolicyCommand 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("AmazonEC2ContainerRegistry_V20150921", "SetRepositoryPolicy", {}).n("ECRClient", "SetRepositoryPolicyCommand").f(void 0, void 0).ser(se_SetRepositoryPolicyCommand).de(de_SetRepositoryPolicyCommand).build() {
+};
+__name(_SetRepositoryPolicyCommand, "SetRepositoryPolicyCommand");
+var SetRepositoryPolicyCommand = _SetRepositoryPolicyCommand;
+
+// src/commands/StartImageScanCommand.ts
+
+
+
+
+var _StartImageScanCommand = class _StartImageScanCommand 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("AmazonEC2ContainerRegistry_V20150921", "StartImageScan", {}).n("ECRClient", "StartImageScanCommand").f(void 0, void 0).ser(se_StartImageScanCommand).de(de_StartImageScanCommand).build() {
+};
+__name(_StartImageScanCommand, "StartImageScanCommand");
+var StartImageScanCommand = _StartImageScanCommand;
+
+// src/commands/StartLifecyclePolicyPreviewCommand.ts
+
+
+
+
+var _StartLifecyclePolicyPreviewCommand = class _StartLifecyclePolicyPreviewCommand 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("AmazonEC2ContainerRegistry_V20150921", "StartLifecyclePolicyPreview", {}).n("ECRClient", "StartLifecyclePolicyPreviewCommand").f(void 0, void 0).ser(se_StartLifecyclePolicyPreviewCommand).de(de_StartLifecyclePolicyPreviewCommand).build() {
+};
+__name(_StartLifecyclePolicyPreviewCommand, "StartLifecyclePolicyPreviewCommand");
+var StartLifecyclePolicyPreviewCommand = _StartLifecyclePolicyPreviewCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand 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("AmazonEC2ContainerRegistry_V20150921", "TagResource", {}).n("ECRClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand 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("AmazonEC2ContainerRegistry_V20150921", "UntagResource", {}).n("ECRClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdatePullThroughCacheRuleCommand.ts
+
+
+
+
+var _UpdatePullThroughCacheRuleCommand = class _UpdatePullThroughCacheRuleCommand 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("AmazonEC2ContainerRegistry_V20150921", "UpdatePullThroughCacheRule", {}).n("ECRClient", "UpdatePullThroughCacheRuleCommand").f(void 0, void 0).ser(se_UpdatePullThroughCacheRuleCommand).de(de_UpdatePullThroughCacheRuleCommand).build() {
+};
+__name(_UpdatePullThroughCacheRuleCommand, "UpdatePullThroughCacheRuleCommand");
+var UpdatePullThroughCacheRuleCommand = _UpdatePullThroughCacheRuleCommand;
+
+// src/commands/UploadLayerPartCommand.ts
+
+
+
+
+var _UploadLayerPartCommand = class _UploadLayerPartCommand 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("AmazonEC2ContainerRegistry_V20150921", "UploadLayerPart", {}).n("ECRClient", "UploadLayerPartCommand").f(void 0, void 0).ser(se_UploadLayerPartCommand).de(de_UploadLayerPartCommand).build() {
+};
+__name(_UploadLayerPartCommand, "UploadLayerPartCommand");
+var UploadLayerPartCommand = _UploadLayerPartCommand;
+
+// src/commands/ValidatePullThroughCacheRuleCommand.ts
+
+
+
+
+var _ValidatePullThroughCacheRuleCommand = class _ValidatePullThroughCacheRuleCommand 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("AmazonEC2ContainerRegistry_V20150921", "ValidatePullThroughCacheRule", {}).n("ECRClient", "ValidatePullThroughCacheRuleCommand").f(void 0, void 0).ser(se_ValidatePullThroughCacheRuleCommand).de(de_ValidatePullThroughCacheRuleCommand).build() {
+};
+__name(_ValidatePullThroughCacheRuleCommand, "ValidatePullThroughCacheRuleCommand");
+var ValidatePullThroughCacheRuleCommand = _ValidatePullThroughCacheRuleCommand;
+
+// src/ECR.ts
+var commands = {
+  BatchCheckLayerAvailabilityCommand,
+  BatchDeleteImageCommand,
+  BatchGetImageCommand,
+  BatchGetRepositoryScanningConfigurationCommand,
+  CompleteLayerUploadCommand,
+  CreatePullThroughCacheRuleCommand,
+  CreateRepositoryCommand,
+  DeleteLifecyclePolicyCommand,
+  DeletePullThroughCacheRuleCommand,
+  DeleteRegistryPolicyCommand,
+  DeleteRepositoryCommand,
+  DeleteRepositoryPolicyCommand,
+  DescribeImageReplicationStatusCommand,
+  DescribeImagesCommand,
+  DescribeImageScanFindingsCommand,
+  DescribePullThroughCacheRulesCommand,
+  DescribeRegistryCommand,
+  DescribeRepositoriesCommand,
+  GetAuthorizationTokenCommand,
+  GetDownloadUrlForLayerCommand,
+  GetLifecyclePolicyCommand,
+  GetLifecyclePolicyPreviewCommand,
+  GetRegistryPolicyCommand,
+  GetRegistryScanningConfigurationCommand,
+  GetRepositoryPolicyCommand,
+  InitiateLayerUploadCommand,
+  ListImagesCommand,
+  ListTagsForResourceCommand,
+  PutImageCommand,
+  PutImageScanningConfigurationCommand,
+  PutImageTagMutabilityCommand,
+  PutLifecyclePolicyCommand,
+  PutRegistryPolicyCommand,
+  PutRegistryScanningConfigurationCommand,
+  PutReplicationConfigurationCommand,
+  SetRepositoryPolicyCommand,
+  StartImageScanCommand,
+  StartLifecyclePolicyPreviewCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdatePullThroughCacheRuleCommand,
+  UploadLayerPartCommand,
+  ValidatePullThroughCacheRuleCommand
+};
+var _ECR = class _ECR extends ECRClient {
+};
+__name(_ECR, "ECR");
+var ECR = _ECR;
+(0, import_smithy_client.createAggregatedClient)(commands, ECR);
+
+// src/pagination/DescribeImageScanFindingsPaginator.ts
+var import_core = require("@smithy/core");
+var paginateDescribeImageScanFindings = (0, import_core.createPaginator)(ECRClient, DescribeImageScanFindingsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeImagesPaginator.ts
+
+var paginateDescribeImages = (0, import_core.createPaginator)(ECRClient, DescribeImagesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribePullThroughCacheRulesPaginator.ts
+
+var paginateDescribePullThroughCacheRules = (0, import_core.createPaginator)(ECRClient, DescribePullThroughCacheRulesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeRepositoriesPaginator.ts
+
+var paginateDescribeRepositories = (0, import_core.createPaginator)(ECRClient, DescribeRepositoriesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/GetLifecyclePolicyPreviewPaginator.ts
+
+var paginateGetLifecyclePolicyPreview = (0, import_core.createPaginator)(ECRClient, GetLifecyclePolicyPreviewCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListImagesPaginator.ts
+
+var paginateListImages = (0, import_core.createPaginator)(ECRClient, ListImagesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/waiters/waitForImageScanComplete.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeImageScanFindingsCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.imageScanStatus.status;
+      }, "returnComparator");
+      if (returnComparator() === "COMPLETE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.imageScanStatus.status;
+      }, "returnComparator");
+      if (returnComparator() === "FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForImageScanComplete = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForImageScanComplete");
+var waitUntilImageScanComplete = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilImageScanComplete");
+
+// src/waiters/waitForLifecyclePolicyPreviewComplete.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetLifecyclePolicyPreviewCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "COMPLETE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForLifecyclePolicyPreviewComplete = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForLifecyclePolicyPreviewComplete");
+var waitUntilLifecyclePolicyPreviewComplete = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilLifecyclePolicyPreviewComplete");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  BatchCheckLayerAvailabilityCommand,
+  BatchDeleteImageCommand,
+  BatchGetImageCommand,
+  BatchGetRepositoryScanningConfigurationCommand,
+  CompleteLayerUploadCommand,
+  CreatePullThroughCacheRuleCommand,
+  CreateRepositoryCommand,
+  DeleteLifecyclePolicyCommand,
+  DeletePullThroughCacheRuleCommand,
+  DeleteRegistryPolicyCommand,
+  DeleteRepositoryCommand,
+  DeleteRepositoryPolicyCommand,
+  DescribeImageReplicationStatusCommand,
+  DescribeImageScanFindingsCommand,
+  DescribeImagesCommand,
+  DescribePullThroughCacheRulesCommand,
+  DescribeRegistryCommand,
+  DescribeRepositoriesCommand,
+  ECR,
+  ECRClient,
+  ECRServiceException,
+  EmptyUploadException,
+  EncryptionType,
+  FindingSeverity,
+  GetAuthorizationTokenCommand,
+  GetDownloadUrlForLayerCommand,
+  GetLifecyclePolicyCommand,
+  GetLifecyclePolicyPreviewCommand,
+  GetRegistryPolicyCommand,
+  GetRegistryScanningConfigurationCommand,
+  GetRepositoryPolicyCommand,
+  ImageActionType,
+  ImageAlreadyExistsException,
+  ImageDigestDoesNotMatchException,
+  ImageFailureCode,
+  ImageNotFoundException,
+  ImageTagAlreadyExistsException,
+  ImageTagMutability,
+  InitiateLayerUploadCommand,
+  InvalidLayerException,
+  InvalidLayerPartException,
+  InvalidParameterException,
+  InvalidTagParameterException,
+  KmsException,
+  LayerAlreadyExistsException,
+  LayerAvailability,
+  LayerFailureCode,
+  LayerInaccessibleException,
+  LayerPartTooSmallException,
+  LayersNotFoundException,
+  LifecyclePolicyNotFoundException,
+  LifecyclePolicyPreviewInProgressException,
+  LifecyclePolicyPreviewNotFoundException,
+  LifecyclePolicyPreviewStatus,
+  LimitExceededException,
+  ListImagesCommand,
+  ListTagsForResourceCommand,
+  PullThroughCacheRuleAlreadyExistsException,
+  PullThroughCacheRuleNotFoundException,
+  PutImageCommand,
+  PutImageScanningConfigurationCommand,
+  PutImageTagMutabilityCommand,
+  PutLifecyclePolicyCommand,
+  PutRegistryPolicyCommand,
+  PutRegistryScanningConfigurationCommand,
+  PutReplicationConfigurationCommand,
+  ReferencedImagesNotFoundException,
+  RegistryPolicyNotFoundException,
+  ReplicationStatus,
+  RepositoryAlreadyExistsException,
+  RepositoryFilterType,
+  RepositoryNotEmptyException,
+  RepositoryNotFoundException,
+  RepositoryPolicyNotFoundException,
+  ScanFrequency,
+  ScanNotFoundException,
+  ScanStatus,
+  ScanType,
+  ScanningConfigurationFailureCode,
+  ScanningRepositoryFilterType,
+  SecretNotFoundException,
+  ServerException,
+  SetRepositoryPolicyCommand,
+  StartImageScanCommand,
+  StartLifecyclePolicyPreviewCommand,
+  TagResourceCommand,
+  TagStatus,
+  TooManyTagsException,
+  UnableToAccessSecretException,
+  UnableToDecryptSecretValueException,
+  UnableToGetUpstreamImageException,
+  UnableToGetUpstreamLayerException,
+  UnsupportedImageTypeException,
+  UnsupportedUpstreamRegistryException,
+  UntagResourceCommand,
+  UpdatePullThroughCacheRuleCommand,
+  UploadLayerPartCommand,
+  UploadNotFoundException,
+  UpstreamRegistry,
+  ValidatePullThroughCacheRuleCommand,
+  ValidationException,
+  __Client,
+  paginateDescribeImageScanFindings,
+  paginateDescribeImages,
+  paginateDescribePullThroughCacheRules,
+  paginateDescribeRepositories,
+  paginateGetLifecyclePolicyPreview,
+  paginateListImages,
+  waitForImageScanComplete,
+  waitForLifecyclePolicyPreviewComplete,
+  waitUntilImageScanComplete,
+  waitUntilLifecyclePolicyPreviewComplete
+});
+