@layerzerolabs/vm-tooling 0.0.30

package/dist/scripts/generate-github-matrix.js

@@ -0,0 +1,1944 @@
+import { parseJsonBody, parseJsonErrorBody, loadRestJsonErrorCode } from '../JY6PMFYV.js';
+import { EndpointCache, awsEndpointFunctions, customEndpointFunctions, resolveUserAgentConfig, resolveRetryConfig, resolveRegionConfig, resolveHostHeaderConfig, resolveEndpointConfig, getUserAgentPlugin, getRetryPlugin, getContentLengthPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, getSerdePlugin, getEndpointPlugin, resolveDefaultsModeConfig, emitWarningIfUnsupportedVersion as emitWarningIfUnsupportedVersion$1, Hash, createDefaultUserAgentProvider, calculateBodyLength, NODE_APP_ID_CONFIG_OPTIONS, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_RETRY_MODE_CONFIG_OPTIONS, DEFAULT_RETRY_MODE, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, resolveAwsSdkSigV4Config, normalizeProvider, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, getSmithyContext, AwsSdkSigV4Signer, resolveEndpoint } from '../RVOOJEDH.js';
+import { ENV_KEY, ENV_SECRET, fromEnv } from '../BHBC6Q3Y.js';
+import { loadConfig, parseUrl } from '../CSNPKKTO.js';
+import { ENV_PROFILE } from '../EASTPCLB.js';
+import { Client, ServiceException, withBaseException, Command, emitWarningIfUnsupportedVersion, streamCollector, NodeHttpHandler, getDefaultExtensionConfiguration, getHttpHandlerExtensionConfiguration, resolveDefaultRuntimeConfig, resolveHttpHandlerRuntimeConfig, _json, NoOpLogger, toBase64, fromBase64, loadConfigsForDefaultMode, HttpRequest, decorateServiceException } from '../F5UPK5ZZ.js';
+import { toUtf8, fromUtf8 } from '../33GUXAT7.js';
+import '../YVV5I7A5.js';
+import '../6UWCX7SA.js';
+import { memoize, chain, CredentialsProviderError } from '../7EXYTS34.js';
+import { versionMatrices } from '../YTUEW27V.js';
+import { __name } from '../VUOMXK5T.js';
+import { Command as Command$1 } from 'commander';
+import { stdout } from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/auth/httpAuthSchemeProvider.js
+var defaultECRHttpAuthSchemeParametersProvider = /* @__PURE__ */ __name(async (config, context, input) => {
+  return {
+    operation: getSmithyContext(context).operation,
+    region: await normalizeProvider(config.region)() || (() => {
+      throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+    })()
+  };
+}, "defaultECRHttpAuthSchemeParametersProvider");
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+  return {
+    schemeId: "aws.auth#sigv4",
+    signingProperties: {
+      name: "ecr",
+      region: authParameters.region
+    },
+    propertiesExtractor: /* @__PURE__ */ __name((config, context) => ({
+      signingProperties: {
+        config,
+        context
+      }
+    }), "propertiesExtractor")
+  };
+}
+__name(createAwsAuthSigv4HttpAuthOption, "createAwsAuthSigv4HttpAuthOption");
+var defaultECRHttpAuthSchemeProvider = /* @__PURE__ */ __name((authParameters) => {
+  const options = [];
+  switch (authParameters.operation) {
+    default: {
+      options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+    }
+  }
+  return options;
+}, "defaultECRHttpAuthSchemeProvider");
+var resolveHttpAuthSchemeConfig = /* @__PURE__ */ __name((config) => {
+  const config_0 = resolveAwsSdkSigV4Config(config);
+  return Object.assign(config_0, {
+    authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
+  });
+}, "resolveHttpAuthSchemeConfig");
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/endpoint/EndpointParameters.js
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return Object.assign(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"
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/package.json
+var package_default = {
+  version: "3.879.0"};
+
+// ../../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.879.0/node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js
+var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
+var remoteProvider = /* @__PURE__ */ __name(async (init) => {
+  const { ENV_CMDS_FULL_URI, ENV_CMDS_RELATIVE_URI, fromContainerMetadata, fromInstanceMetadata } = await import('../E75FXJNJ.js');
+  if (process.env[ENV_CMDS_RELATIVE_URI] || process.env[ENV_CMDS_FULL_URI]) {
+    init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromHttp/fromContainerMetadata");
+    const { fromHttp } = await import('../WBKUP4MX.js');
+    return chain(fromHttp(init), fromContainerMetadata(init));
+  }
+  if (process.env[ENV_IMDS_DISABLED] && process.env[ENV_IMDS_DISABLED] !== "false") {
+    return async () => {
+      throw new CredentialsProviderError("EC2 Instance Metadata Service access disabled", {
+        logger: init.logger
+      });
+    };
+  }
+  init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromInstanceMetadata");
+  return fromInstanceMetadata(init);
+}, "remoteProvider");
+
+// ../../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.879.0/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
+var multipleCredentialSourceWarningEmitted = false;
+var defaultProvider = /* @__PURE__ */ __name((init = {}) => memoize(chain(async () => {
+  const profile = init.profile ?? process.env[ENV_PROFILE];
+  if (profile) {
+    const envStaticCredentialsAreSet = process.env[ENV_KEY] && process.env[ENV_SECRET];
+    if (envStaticCredentialsAreSet) {
+      if (!multipleCredentialSourceWarningEmitted) {
+        const warnFn = init.logger?.warn && init.logger?.constructor?.name !== "NoOpLogger" ? init.logger.warn : console.warn;
+        warnFn(`@aws-sdk/credential-provider-node - defaultProvider::fromEnv WARNING:
+    Multiple credential sources detected: 
+    Both AWS_PROFILE and the pair AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY static credentials are set.
+    This SDK will proceed with the AWS_PROFILE value.
+    
+    However, a future version may change this behavior to prefer the ENV static credentials.
+    Please ensure that your environment only sets either the AWS_PROFILE or the
+    AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY pair.
+`);
+        multipleCredentialSourceWarningEmitted = true;
+      }
+    }
+    throw new CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", {
+      logger: init.logger,
+      tryNextLink: true
+    });
+  }
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv");
+  return fromEnv(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromSSO");
+  const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init;
+  if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
+    throw new CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", {
+      logger: init.logger
+    });
+  }
+  const { fromSSO } = await import('../WAGFMHUT.js');
+  return fromSSO(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni");
+  const { fromIni } = await import('../OWJM6QQP.js');
+  return fromIni(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess");
+  const { fromProcess } = await import('../OU33HN4T.js');
+  return fromProcess(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile");
+  const { fromTokenFile } = await import('../EQPMZDRH.js');
+  return fromTokenFile(init)();
+}, async () => {
+  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider");
+  return (await remoteProvider(init))();
+}, async () => {
+  throw new CredentialsProviderError("Could not load credentials from any providers", {
+    tryNextLink: false,
+    logger: init.logger
+  });
+}), credentialsTreatedAsExpired, credentialsWillNeedRefresh), "defaultProvider");
+var credentialsWillNeedRefresh = /* @__PURE__ */ __name((credentials) => credentials?.expiration !== void 0, "credentialsWillNeedRefresh");
+var credentialsTreatedAsExpired = /* @__PURE__ */ __name((credentials) => credentials?.expiration !== void 0 && credentials.expiration.getTime() - Date.now() < 3e5, "credentialsTreatedAsExpired");
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/endpoint/ruleset.js
+var B = "required";
+var C = "fn";
+var D = "argv";
+var E = "ref";
+var F = "url";
+var G = "properties";
+var H = "headers";
+var a = true;
+var b = "isSet";
+var c = "booleanEquals";
+var d = "error";
+var e = "endpoint";
+var f = "tree";
+var g = "PartitionResult";
+var h = "stringEquals";
+var i = "aws";
+var j = "aws-us-gov";
+var k = {
+  [B]: false,
+  "type": "String"
+};
+var l = {
+  [B]: true,
+  "default": false,
+  "type": "Boolean"
+};
+var m = {
+  [E]: "Endpoint"
+};
+var n = {
+  [C]: c,
+  [D]: [
+    {
+      [E]: "UseFIPS"
+    },
+    true
+  ]
+};
+var o = {
+  [C]: c,
+  [D]: [
+    {
+      [E]: "UseDualStack"
+    },
+    true
+  ]
+};
+var p = {};
+var q = {
+  [C]: "getAttr",
+  [D]: [
+    {
+      [E]: g
+    },
+    "supportsFIPS"
+  ]
+};
+var r = {
+  [C]: c,
+  [D]: [
+    true,
+    {
+      [C]: "getAttr",
+      [D]: [
+        {
+          [E]: g
+        },
+        "supportsDualStack"
+      ]
+    }
+  ]
+};
+var s = {
+  [C]: "getAttr",
+  [D]: [
+    {
+      [E]: g
+    },
+    "name"
+  ]
+};
+var t = {
+  [F]: "https://ecr-fips.{Region}.api.aws",
+  [G]: {},
+  [H]: {}
+};
+var u = {
+  [F]: "https://ecr-fips.{Region}.amazonaws.com",
+  [G]: {},
+  [H]: {}
+};
+var v = {
+  [F]: "https://ecr.{Region}.api.aws",
+  [G]: {},
+  [H]: {}
+};
+var w = [
+  n
+];
+var x = [
+  o
+];
+var y = [
+  {
+    [E]: "Region"
+  }
+];
+var z = [
+  {
+    [C]: h,
+    [D]: [
+      i,
+      s
+    ]
+  }
+];
+var A = [
+  {
+    [C]: h,
+    [D]: [
+      j,
+      s
+    ]
+  }
+];
+var _data = {
+  version: "1.0",
+  parameters: {
+    Region: k,
+    UseDualStack: l,
+    UseFIPS: l,
+    Endpoint: k
+  },
+  rules: [
+    {
+      conditions: [
+        {
+          [C]: b,
+          [D]: [
+            m
+          ]
+        }
+      ],
+      rules: [
+        {
+          conditions: w,
+          error: "Invalid Configuration: FIPS and custom endpoint are not supported",
+          type: d
+        },
+        {
+          conditions: x,
+          error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
+          type: d
+        },
+        {
+          endpoint: {
+            [F]: m,
+            [G]: p,
+            [H]: p
+          },
+          type: e
+        }
+      ],
+      type: f
+    },
+    {
+      conditions: [
+        {
+          [C]: b,
+          [D]: y
+        }
+      ],
+      rules: [
+        {
+          conditions: [
+            {
+              [C]: "aws.partition",
+              [D]: y,
+              assign: g
+            }
+          ],
+          rules: [
+            {
+              conditions: [
+                n,
+                o
+              ],
+              rules: [
+                {
+                  conditions: [
+                    {
+                      [C]: c,
+                      [D]: [
+                        a,
+                        q
+                      ]
+                    },
+                    r
+                  ],
+                  rules: [
+                    {
+                      conditions: z,
+                      endpoint: t,
+                      type: e
+                    },
+                    {
+                      conditions: A,
+                      endpoint: t,
+                      type: e
+                    },
+                    {
+                      endpoint: {
+                        [F]: "https://api.ecr-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                        [G]: p,
+                        [H]: p
+                      },
+                      type: e
+                    }
+                  ],
+                  type: f
+                },
+                {
+                  error: "FIPS and DualStack are enabled, but this partition does not support one or both",
+                  type: d
+                }
+              ],
+              type: f
+            },
+            {
+              conditions: w,
+              rules: [
+                {
+                  conditions: [
+                    {
+                      [C]: c,
+                      [D]: [
+                        q,
+                        a
+                      ]
+                    }
+                  ],
+                  rules: [
+                    {
+                      conditions: [
+                        {
+                          [C]: h,
+                          [D]: [
+                            s,
+                            i
+                          ]
+                        }
+                      ],
+                      endpoint: u,
+                      type: e
+                    },
+                    {
+                      conditions: [
+                        {
+                          [C]: h,
+                          [D]: [
+                            s,
+                            j
+                          ]
+                        }
+                      ],
+                      endpoint: u,
+                      type: e
+                    },
+                    {
+                      endpoint: {
+                        [F]: "https://api.ecr-fips.{Region}.{PartitionResult#dnsSuffix}",
+                        [G]: p,
+                        [H]: p
+                      },
+                      type: e
+                    }
+                  ],
+                  type: f
+                },
+                {
+                  error: "FIPS is enabled but this partition does not support FIPS",
+                  type: d
+                }
+              ],
+              type: f
+            },
+            {
+              conditions: x,
+              rules: [
+                {
+                  conditions: [
+                    r
+                  ],
+                  rules: [
+                    {
+                      conditions: z,
+                      endpoint: v,
+                      type: e
+                    },
+                    {
+                      conditions: [
+                        {
+                          [C]: h,
+                          [D]: [
+                            "aws-cn",
+                            s
+                          ]
+                        }
+                      ],
+                      endpoint: {
+                        [F]: "https://ecr.{Region}.api.amazonwebservices.com.cn",
+                        [G]: p,
+                        [H]: p
+                      },
+                      type: e
+                    },
+                    {
+                      conditions: A,
+                      endpoint: v,
+                      type: e
+                    },
+                    {
+                      endpoint: {
+                        [F]: "https://api.ecr.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                        [G]: p,
+                        [H]: p
+                      },
+                      type: e
+                    }
+                  ],
+                  type: f
+                },
+                {
+                  error: "DualStack is enabled but this partition does not support DualStack",
+                  type: d
+                }
+              ],
+              type: f
+            },
+            {
+              endpoint: {
+                [F]: "https://api.ecr.{Region}.{PartitionResult#dnsSuffix}",
+                [G]: p,
+                [H]: p
+              },
+              type: e
+            }
+          ],
+          type: f
+        }
+      ],
+      type: f
+    },
+    {
+      error: "Invalid Configuration: Missing Region",
+      type: d
+    }
+  ]
+};
+var ruleSet = _data;
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/endpoint/endpointResolver.js
+var cache = new EndpointCache({
+  size: 50,
+  params: [
+    "Endpoint",
+    "Region",
+    "UseDualStack",
+    "UseFIPS"
+  ]
+});
+var defaultEndpointResolver = /* @__PURE__ */ __name((endpointParams, context = {}) => {
+  return cache.get(endpointParams, () => resolveEndpoint(ruleSet, {
+    endpointParams,
+    logger: context.logger
+  }));
+}, "defaultEndpointResolver");
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/runtimeConfig.shared.js
+var getRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    apiVersion: "2015-09-21",
+    base64Decoder: config?.base64Decoder ?? fromBase64,
+    base64Encoder: config?.base64Encoder ?? toBase64,
+    disableHostPrefix: config?.disableHostPrefix ?? false,
+    endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+    extensions: config?.extensions ?? [],
+    httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultECRHttpAuthSchemeProvider,
+    httpAuthSchemes: config?.httpAuthSchemes ?? [
+      {
+        schemeId: "aws.auth#sigv4",
+        identityProvider: /* @__PURE__ */ __name((ipc) => ipc.getIdentityProvider("aws.auth#sigv4"), "identityProvider"),
+        signer: new AwsSdkSigV4Signer()
+      }
+    ],
+    logger: config?.logger ?? new NoOpLogger(),
+    serviceId: config?.serviceId ?? "ECR",
+    urlParser: config?.urlParser ?? parseUrl,
+    utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+    utf8Encoder: config?.utf8Encoder ?? toUtf8
+  };
+}, "getRuntimeConfig");
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/runtimeConfig.js
+var getRuntimeConfig2 = /* @__PURE__ */ __name((config) => {
+  emitWarningIfUnsupportedVersion(process.version);
+  const defaultsMode = resolveDefaultsModeConfig(config);
+  const defaultConfigProvider = /* @__PURE__ */ __name(() => defaultsMode().then(loadConfigsForDefaultMode), "defaultConfigProvider");
+  const clientSharedValues = getRuntimeConfig(config);
+  emitWarningIfUnsupportedVersion$1(process.version);
+  const loaderConfig = {
+    profile: config?.profile,
+    logger: clientSharedValues.logger
+  };
+  return {
+    ...clientSharedValues,
+    ...config,
+    runtime: "node",
+    defaultsMode,
+    authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+    bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+    credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+    defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({
+      serviceId: clientSharedValues.serviceId,
+      clientVersion: package_default.version
+    }),
+    maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+    region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, {
+      ...NODE_REGION_CONFIG_FILE_OPTIONS,
+      ...loaderConfig
+    }),
+    requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+    retryMode: config?.retryMode ?? loadConfig({
+      ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+      default: /* @__PURE__ */ __name(async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE, "default")
+    }, config),
+    sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+    streamCollector: config?.streamCollector ?? streamCollector,
+    useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+    useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+    userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
+  };
+}, "getRuntimeConfig");
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/auth/httpAuthExtensionConfiguration.js
+var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+}, "getHttpAuthExtensionConfiguration");
+var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+}, "resolveHttpAuthRuntimeConfig");
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/runtimeExtensions.js
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+}, "resolveRuntimeExtensions");
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/ECRClient.js
+var ECRClient = class extends Client {
+  static {
+    __name(this, "ECRClient");
+  }
+  config;
+  constructor(...[configuration]) {
+    const _config_0 = getRuntimeConfig2(configuration || {});
+    super(_config_0);
+    this.initConfig = _config_0;
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = resolveUserAgentConfig(_config_1);
+    const _config_3 = resolveRetryConfig(_config_2);
+    const _config_4 = resolveRegionConfig(_config_3);
+    const _config_5 = resolveHostHeaderConfig(_config_4);
+    const _config_6 = resolveEndpointConfig(_config_5);
+    const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+    this.config = _config_8;
+    this.middlewareStack.use(getUserAgentPlugin(this.config));
+    this.middlewareStack.use(getRetryPlugin(this.config));
+    this.middlewareStack.use(getContentLengthPlugin(this.config));
+    this.middlewareStack.use(getHostHeaderPlugin(this.config));
+    this.middlewareStack.use(getLoggerPlugin(this.config));
+    this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+    this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+      httpAuthSchemeParametersProvider: defaultECRHttpAuthSchemeParametersProvider,
+      identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new DefaultIdentityProviderConfig({
+        "aws.auth#sigv4": config.credentials
+      }), "identityProviderConfigProvider")
+    }));
+    this.middlewareStack.use(getHttpSigningPlugin(this.config));
+  }
+  destroy() {
+    super.destroy();
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/models/ECRServiceException.js
+var ECRServiceException = class _ECRServiceException extends ServiceException {
+  static {
+    __name(this, "ECRServiceException");
+  }
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ECRServiceException.prototype);
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/models/models_0.js
+var InvalidParameterException = class _InvalidParameterException extends ECRServiceException {
+  static {
+    __name(this, "InvalidParameterException");
+  }
+  name = "InvalidParameterException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidParameterException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
+  }
+};
+var RepositoryNotFoundException = class _RepositoryNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "RepositoryNotFoundException");
+  }
+  name = "RepositoryNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "RepositoryNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _RepositoryNotFoundException.prototype);
+  }
+};
+var ServerException = class _ServerException extends ECRServiceException {
+  static {
+    __name(this, "ServerException");
+  }
+  name = "ServerException";
+  $fault = "server";
+  constructor(opts) {
+    super({
+      name: "ServerException",
+      $fault: "server",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ServerException.prototype);
+  }
+};
+var LimitExceededException = class _LimitExceededException extends ECRServiceException {
+  static {
+    __name(this, "LimitExceededException");
+  }
+  name = "LimitExceededException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+  }
+};
+var UnableToGetUpstreamImageException = class _UnableToGetUpstreamImageException extends ECRServiceException {
+  static {
+    __name(this, "UnableToGetUpstreamImageException");
+  }
+  name = "UnableToGetUpstreamImageException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "UnableToGetUpstreamImageException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _UnableToGetUpstreamImageException.prototype);
+  }
+};
+var ValidationException = class _ValidationException extends ECRServiceException {
+  static {
+    __name(this, "ValidationException");
+  }
+  name = "ValidationException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+  }
+};
+var EmptyUploadException = class _EmptyUploadException extends ECRServiceException {
+  static {
+    __name(this, "EmptyUploadException");
+  }
+  name = "EmptyUploadException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "EmptyUploadException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _EmptyUploadException.prototype);
+  }
+};
+var InvalidLayerException = class _InvalidLayerException extends ECRServiceException {
+  static {
+    __name(this, "InvalidLayerException");
+  }
+  name = "InvalidLayerException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidLayerException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidLayerException.prototype);
+  }
+};
+var KmsException = class _KmsException extends ECRServiceException {
+  static {
+    __name(this, "KmsException");
+  }
+  name = "KmsException";
+  $fault = "client";
+  kmsError;
+  constructor(opts) {
+    super({
+      name: "KmsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _KmsException.prototype);
+    this.kmsError = opts.kmsError;
+  }
+};
+var LayerAlreadyExistsException = class _LayerAlreadyExistsException extends ECRServiceException {
+  static {
+    __name(this, "LayerAlreadyExistsException");
+  }
+  name = "LayerAlreadyExistsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "LayerAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _LayerAlreadyExistsException.prototype);
+  }
+};
+var LayerPartTooSmallException = class _LayerPartTooSmallException extends ECRServiceException {
+  static {
+    __name(this, "LayerPartTooSmallException");
+  }
+  name = "LayerPartTooSmallException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "LayerPartTooSmallException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _LayerPartTooSmallException.prototype);
+  }
+};
+var UploadNotFoundException = class _UploadNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "UploadNotFoundException");
+  }
+  name = "UploadNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "UploadNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _UploadNotFoundException.prototype);
+  }
+};
+var PullThroughCacheRuleAlreadyExistsException = class _PullThroughCacheRuleAlreadyExistsException extends ECRServiceException {
+  static {
+    __name(this, "PullThroughCacheRuleAlreadyExistsException");
+  }
+  name = "PullThroughCacheRuleAlreadyExistsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "PullThroughCacheRuleAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _PullThroughCacheRuleAlreadyExistsException.prototype);
+  }
+};
+var SecretNotFoundException = class _SecretNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "SecretNotFoundException");
+  }
+  name = "SecretNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "SecretNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _SecretNotFoundException.prototype);
+  }
+};
+var UnableToAccessSecretException = class _UnableToAccessSecretException extends ECRServiceException {
+  static {
+    __name(this, "UnableToAccessSecretException");
+  }
+  name = "UnableToAccessSecretException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "UnableToAccessSecretException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _UnableToAccessSecretException.prototype);
+  }
+};
+var UnableToDecryptSecretValueException = class _UnableToDecryptSecretValueException extends ECRServiceException {
+  static {
+    __name(this, "UnableToDecryptSecretValueException");
+  }
+  name = "UnableToDecryptSecretValueException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "UnableToDecryptSecretValueException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _UnableToDecryptSecretValueException.prototype);
+  }
+};
+var UnsupportedUpstreamRegistryException = class _UnsupportedUpstreamRegistryException extends ECRServiceException {
+  static {
+    __name(this, "UnsupportedUpstreamRegistryException");
+  }
+  name = "UnsupportedUpstreamRegistryException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "UnsupportedUpstreamRegistryException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _UnsupportedUpstreamRegistryException.prototype);
+  }
+};
+var InvalidTagParameterException = class _InvalidTagParameterException extends ECRServiceException {
+  static {
+    __name(this, "InvalidTagParameterException");
+  }
+  name = "InvalidTagParameterException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "InvalidTagParameterException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidTagParameterException.prototype);
+  }
+};
+var RepositoryAlreadyExistsException = class _RepositoryAlreadyExistsException extends ECRServiceException {
+  static {
+    __name(this, "RepositoryAlreadyExistsException");
+  }
+  name = "RepositoryAlreadyExistsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "RepositoryAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _RepositoryAlreadyExistsException.prototype);
+  }
+};
+var TooManyTagsException = class _TooManyTagsException extends ECRServiceException {
+  static {
+    __name(this, "TooManyTagsException");
+  }
+  name = "TooManyTagsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+  }
+};
+var TemplateAlreadyExistsException = class _TemplateAlreadyExistsException extends ECRServiceException {
+  static {
+    __name(this, "TemplateAlreadyExistsException");
+  }
+  name = "TemplateAlreadyExistsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "TemplateAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TemplateAlreadyExistsException.prototype);
+  }
+};
+var LifecyclePolicyNotFoundException = class _LifecyclePolicyNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "LifecyclePolicyNotFoundException");
+  }
+  name = "LifecyclePolicyNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "LifecyclePolicyNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _LifecyclePolicyNotFoundException.prototype);
+  }
+};
+var PullThroughCacheRuleNotFoundException = class _PullThroughCacheRuleNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "PullThroughCacheRuleNotFoundException");
+  }
+  name = "PullThroughCacheRuleNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "PullThroughCacheRuleNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _PullThroughCacheRuleNotFoundException.prototype);
+  }
+};
+var RegistryPolicyNotFoundException = class _RegistryPolicyNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "RegistryPolicyNotFoundException");
+  }
+  name = "RegistryPolicyNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "RegistryPolicyNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _RegistryPolicyNotFoundException.prototype);
+  }
+};
+var RepositoryNotEmptyException = class _RepositoryNotEmptyException extends ECRServiceException {
+  static {
+    __name(this, "RepositoryNotEmptyException");
+  }
+  name = "RepositoryNotEmptyException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "RepositoryNotEmptyException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _RepositoryNotEmptyException.prototype);
+  }
+};
+var TemplateNotFoundException = class _TemplateNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "TemplateNotFoundException");
+  }
+  name = "TemplateNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "TemplateNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TemplateNotFoundException.prototype);
+  }
+};
+var RepositoryPolicyNotFoundException = class _RepositoryPolicyNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "RepositoryPolicyNotFoundException");
+  }
+  name = "RepositoryPolicyNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "RepositoryPolicyNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _RepositoryPolicyNotFoundException.prototype);
+  }
+};
+var ImageNotFoundException = class _ImageNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "ImageNotFoundException");
+  }
+  name = "ImageNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ImageNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ImageNotFoundException.prototype);
+  }
+};
+var ScanNotFoundException = class _ScanNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "ScanNotFoundException");
+  }
+  name = "ScanNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ScanNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ScanNotFoundException.prototype);
+  }
+};
+var LayerInaccessibleException = class _LayerInaccessibleException extends ECRServiceException {
+  static {
+    __name(this, "LayerInaccessibleException");
+  }
+  name = "LayerInaccessibleException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "LayerInaccessibleException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _LayerInaccessibleException.prototype);
+  }
+};
+var LayersNotFoundException = class _LayersNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "LayersNotFoundException");
+  }
+  name = "LayersNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "LayersNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _LayersNotFoundException.prototype);
+  }
+};
+var UnableToGetUpstreamLayerException = class _UnableToGetUpstreamLayerException extends ECRServiceException {
+  static {
+    __name(this, "UnableToGetUpstreamLayerException");
+  }
+  name = "UnableToGetUpstreamLayerException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "UnableToGetUpstreamLayerException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _UnableToGetUpstreamLayerException.prototype);
+  }
+};
+var LifecyclePolicyPreviewNotFoundException = class _LifecyclePolicyPreviewNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "LifecyclePolicyPreviewNotFoundException");
+  }
+  name = "LifecyclePolicyPreviewNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "LifecyclePolicyPreviewNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _LifecyclePolicyPreviewNotFoundException.prototype);
+  }
+};
+var ImageAlreadyExistsException = class _ImageAlreadyExistsException extends ECRServiceException {
+  static {
+    __name(this, "ImageAlreadyExistsException");
+  }
+  name = "ImageAlreadyExistsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ImageAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ImageAlreadyExistsException.prototype);
+  }
+};
+var ImageDigestDoesNotMatchException = class _ImageDigestDoesNotMatchException extends ECRServiceException {
+  static {
+    __name(this, "ImageDigestDoesNotMatchException");
+  }
+  name = "ImageDigestDoesNotMatchException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ImageDigestDoesNotMatchException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ImageDigestDoesNotMatchException.prototype);
+  }
+};
+var ImageTagAlreadyExistsException = class _ImageTagAlreadyExistsException extends ECRServiceException {
+  static {
+    __name(this, "ImageTagAlreadyExistsException");
+  }
+  name = "ImageTagAlreadyExistsException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ImageTagAlreadyExistsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ImageTagAlreadyExistsException.prototype);
+  }
+};
+var ReferencedImagesNotFoundException = class _ReferencedImagesNotFoundException extends ECRServiceException {
+  static {
+    __name(this, "ReferencedImagesNotFoundException");
+  }
+  name = "ReferencedImagesNotFoundException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "ReferencedImagesNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ReferencedImagesNotFoundException.prototype);
+  }
+};
+var UnsupportedImageTypeException = class _UnsupportedImageTypeException extends ECRServiceException {
+  static {
+    __name(this, "UnsupportedImageTypeException");
+  }
+  name = "UnsupportedImageTypeException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "UnsupportedImageTypeException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _UnsupportedImageTypeException.prototype);
+  }
+};
+var LifecyclePolicyPreviewInProgressException = class _LifecyclePolicyPreviewInProgressException extends ECRServiceException {
+  static {
+    __name(this, "LifecyclePolicyPreviewInProgressException");
+  }
+  name = "LifecyclePolicyPreviewInProgressException";
+  $fault = "client";
+  constructor(opts) {
+    super({
+      name: "LifecyclePolicyPreviewInProgressException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _LifecyclePolicyPreviewInProgressException.prototype);
+  }
+};
+var InvalidLayerPartException = class _InvalidLayerPartException extends ECRServiceException {
+  static {
+    __name(this, "InvalidLayerPartException");
+  }
+  name = "InvalidLayerPartException";
+  $fault = "client";
+  registryId;
+  repositoryName;
+  uploadId;
+  lastValidByteReceived;
+  constructor(opts) {
+    super({
+      name: "InvalidLayerPartException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InvalidLayerPartException.prototype);
+    this.registryId = opts.registryId;
+    this.repositoryName = opts.repositoryName;
+    this.uploadId = opts.uploadId;
+    this.lastValidByteReceived = opts.lastValidByteReceived;
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/protocols/Aws_json1_1.js
+var se_ListImagesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListImages");
+  let body;
+  body = JSON.stringify(_json(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListImagesCommand");
+var de_ListImagesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const data = await parseJsonBody(output.body, context);
+  let contents = {};
+  contents = _json(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListImagesCommand");
+var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseJsonErrorBody(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 "LimitExceededException":
+    case "com.amazonaws.ecr#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "UnableToGetUpstreamImageException":
+    case "com.amazonaws.ecr#UnableToGetUpstreamImageException":
+      throw await de_UnableToGetUpstreamImageExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ecr#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    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 "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 "UploadNotFoundException":
+    case "com.amazonaws.ecr#UploadNotFoundException":
+      throw await de_UploadNotFoundExceptionRes(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 "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 "InvalidTagParameterException":
+    case "com.amazonaws.ecr#InvalidTagParameterException":
+      throw await de_InvalidTagParameterExceptionRes(parsedOutput, context);
+    case "RepositoryAlreadyExistsException":
+    case "com.amazonaws.ecr#RepositoryAlreadyExistsException":
+      throw await de_RepositoryAlreadyExistsExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.ecr#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    case "TemplateAlreadyExistsException":
+    case "com.amazonaws.ecr#TemplateAlreadyExistsException":
+      throw await de_TemplateAlreadyExistsExceptionRes(parsedOutput, context);
+    case "LifecyclePolicyNotFoundException":
+    case "com.amazonaws.ecr#LifecyclePolicyNotFoundException":
+      throw await de_LifecyclePolicyNotFoundExceptionRes(parsedOutput, context);
+    case "PullThroughCacheRuleNotFoundException":
+    case "com.amazonaws.ecr#PullThroughCacheRuleNotFoundException":
+      throw await de_PullThroughCacheRuleNotFoundExceptionRes(parsedOutput, context);
+    case "RegistryPolicyNotFoundException":
+    case "com.amazonaws.ecr#RegistryPolicyNotFoundException":
+      throw await de_RegistryPolicyNotFoundExceptionRes(parsedOutput, context);
+    case "RepositoryNotEmptyException":
+    case "com.amazonaws.ecr#RepositoryNotEmptyException":
+      throw await de_RepositoryNotEmptyExceptionRes(parsedOutput, context);
+    case "TemplateNotFoundException":
+    case "com.amazonaws.ecr#TemplateNotFoundException":
+      throw await de_TemplateNotFoundExceptionRes(parsedOutput, context);
+    case "RepositoryPolicyNotFoundException":
+    case "com.amazonaws.ecr#RepositoryPolicyNotFoundException":
+      throw await de_RepositoryPolicyNotFoundExceptionRes(parsedOutput, context);
+    case "ImageNotFoundException":
+    case "com.amazonaws.ecr#ImageNotFoundException":
+      throw await de_ImageNotFoundExceptionRes(parsedOutput, context);
+    case "ScanNotFoundException":
+    case "com.amazonaws.ecr#ScanNotFoundException":
+      throw await de_ScanNotFoundExceptionRes(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 "UnableToGetUpstreamLayerException":
+    case "com.amazonaws.ecr#UnableToGetUpstreamLayerException":
+      throw await de_UnableToGetUpstreamLayerExceptionRes(parsedOutput, context);
+    case "LifecyclePolicyPreviewNotFoundException":
+    case "com.amazonaws.ecr#LifecyclePolicyPreviewNotFoundException":
+      throw await de_LifecyclePolicyPreviewNotFoundExceptionRes(parsedOutput, context);
+    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 "ReferencedImagesNotFoundException":
+    case "com.amazonaws.ecr#ReferencedImagesNotFoundException":
+      throw await de_ReferencedImagesNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedImageTypeException":
+    case "com.amazonaws.ecr#UnsupportedImageTypeException":
+      throw await de_UnsupportedImageTypeExceptionRes(parsedOutput, context);
+    case "LifecyclePolicyPreviewInProgressException":
+    case "com.amazonaws.ecr#LifecyclePolicyPreviewInProgressException":
+      throw await de_LifecyclePolicyPreviewInProgressExceptionRes(parsedOutput, context);
+    case "InvalidLayerPartException":
+    case "com.amazonaws.ecr#InvalidLayerPartException":
+      throw await de_InvalidLayerPartExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CommandError");
+var de_EmptyUploadExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new EmptyUploadException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_EmptyUploadExceptionRes");
+var de_ImageAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ImageAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_ImageAlreadyExistsExceptionRes");
+var de_ImageDigestDoesNotMatchExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ImageDigestDoesNotMatchException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_ImageDigestDoesNotMatchExceptionRes");
+var de_ImageNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ImageNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_ImageNotFoundExceptionRes");
+var de_ImageTagAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ImageTagAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_ImageTagAlreadyExistsExceptionRes");
+var de_InvalidLayerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidLayerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_InvalidLayerExceptionRes");
+var de_InvalidLayerPartExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidLayerPartException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_InvalidLayerPartExceptionRes");
+var de_InvalidParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidParameterException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_InvalidParameterExceptionRes");
+var de_InvalidTagParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new InvalidTagParameterException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_InvalidTagParameterExceptionRes");
+var de_KmsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new KmsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_KmsExceptionRes");
+var de_LayerAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new LayerAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_LayerAlreadyExistsExceptionRes");
+var de_LayerInaccessibleExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new LayerInaccessibleException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_LayerInaccessibleExceptionRes");
+var de_LayerPartTooSmallExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new LayerPartTooSmallException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_LayerPartTooSmallExceptionRes");
+var de_LayersNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new LayersNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_LayersNotFoundExceptionRes");
+var de_LifecyclePolicyNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new LifecyclePolicyNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_LifecyclePolicyNotFoundExceptionRes");
+var de_LifecyclePolicyPreviewInProgressExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new LifecyclePolicyPreviewInProgressException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_LifecyclePolicyPreviewInProgressExceptionRes");
+var de_LifecyclePolicyPreviewNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new LifecyclePolicyPreviewNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_LifecyclePolicyPreviewNotFoundExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_PullThroughCacheRuleAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new PullThroughCacheRuleAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_PullThroughCacheRuleAlreadyExistsExceptionRes");
+var de_PullThroughCacheRuleNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new PullThroughCacheRuleNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_PullThroughCacheRuleNotFoundExceptionRes");
+var de_ReferencedImagesNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ReferencedImagesNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_ReferencedImagesNotFoundExceptionRes");
+var de_RegistryPolicyNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new RegistryPolicyNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_RegistryPolicyNotFoundExceptionRes");
+var de_RepositoryAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new RepositoryAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_RepositoryAlreadyExistsExceptionRes");
+var de_RepositoryNotEmptyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new RepositoryNotEmptyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_RepositoryNotEmptyExceptionRes");
+var de_RepositoryNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new RepositoryNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_RepositoryNotFoundExceptionRes");
+var de_RepositoryPolicyNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new RepositoryPolicyNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_RepositoryPolicyNotFoundExceptionRes");
+var de_ScanNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ScanNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_ScanNotFoundExceptionRes");
+var de_SecretNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new SecretNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_SecretNotFoundExceptionRes");
+var de_ServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_ServerExceptionRes");
+var de_TemplateAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new TemplateAlreadyExistsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_TemplateAlreadyExistsExceptionRes");
+var de_TemplateNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new TemplateNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_TemplateNotFoundExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_TooManyTagsExceptionRes");
+var de_UnableToAccessSecretExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new UnableToAccessSecretException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_UnableToAccessSecretExceptionRes");
+var de_UnableToDecryptSecretValueExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new UnableToDecryptSecretValueException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_UnableToDecryptSecretValueExceptionRes");
+var de_UnableToGetUpstreamImageExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new UnableToGetUpstreamImageException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_UnableToGetUpstreamImageExceptionRes");
+var de_UnableToGetUpstreamLayerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new UnableToGetUpstreamLayerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_UnableToGetUpstreamLayerExceptionRes");
+var de_UnsupportedImageTypeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new UnsupportedImageTypeException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_UnsupportedImageTypeExceptionRes");
+var de_UnsupportedUpstreamRegistryExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new UnsupportedUpstreamRegistryException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_UnsupportedUpstreamRegistryExceptionRes");
+var de_UploadNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new UploadNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_UploadNotFoundExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = _json(body);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return decorateServiceException(exception, body);
+}, "de_ValidationExceptionRes");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var throwDefaultError = 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 HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `AmazonEC2ContainerRegistry_V20150921.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+
+// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/commands/ListImagesCommand.js
+var ListImagesCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o2) {
+  return [
+    getSerdePlugin(config, this.serialize, this.deserialize),
+    getEndpointPlugin(config, Command3.getEndpointParameterInstructions())
+  ];
+}).s("AmazonEC2ContainerRegistry_V20150921", "ListImages", {}).n("ECRClient", "ListImagesCommand").f(void 0, void 0).ser(se_ListImagesCommand).de(de_ListImagesCommand).build() {
+  static {
+    __name(this, "ListImagesCommand");
+  }
+};
+var tagSeparators = [
+  "-",
+  "_"
+];
+var toolTypeWhitelist = [
+  "aptos",
+  "starknet",
+  "sui"
+];
+var ecrClient = new ECRClient();
+var command = new Command$1().name("generate-github-matrix").requiredOption("--registry <registry>").parse();
+var { registry } = command.opts();
+var compileVersionMatrix = /* @__PURE__ */ __name(async ({ toolType, combinations }) => {
+  const repository = `layerzerolabs/${toolType}-tooling`;
+  let existingTags = /* @__PURE__ */ new Set();
+  try {
+    const imageIds = [];
+    let nextToken;
+    do {
+      const response = await ecrClient.send(new ListImagesCommand({
+        filter: {
+          tagStatus: "TAGGED"
+        },
+        nextToken,
+        repositoryName: repository
+      }));
+      imageIds.push(...response.imageIds ?? []);
+      nextToken = response.nextToken;
+    } while (nextToken);
+    existingTags = new Set(imageIds.map(({ imageTag }) => imageTag));
+  } catch (error) {
+    if (!(error instanceof RepositoryNotFoundException)) {
+      throw error;
+    }
+    console.error(error.message);
+  }
+  console.error(`Existing tags for ${toolType}:`, [
+    ...existingTags
+  ]);
+  return combinations.map(({ versions }) => ({
+    build_args: Object.entries(versions).sort().map(([key, value]) => `${key.toUpperCase()}_VERSION=${value}`),
+    directory: toolType,
+    repository,
+    tags: tagSeparators.map((separator) => Object.entries(versions).sort().flat().join(separator)).map((tag) => `${registry}/${repository}:${tag}`)
+  })).filter(({ tags }) => !tags.some((tag) => existingTags.has(tag.split(":").at(-1))));
+}, "compileVersionMatrix");
+var main = /* @__PURE__ */ __name(async () => {
+  const entries = (await Promise.all(versionMatrices.filter(({ toolType }) => toolTypeWhitelist.includes(toolType)).map(compileVersionMatrix))).flat();
+  console.error("GitHub Action matrix generated:", entries);
+  stdout.write(JSON.stringify({
+    toolchain: entries
+  }));
+}, "main");
+if (import.meta.url.startsWith("file:") && process.argv[1] === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+//# sourceMappingURL=generate-github-matrix.js.map
+//# sourceMappingURL=generate-github-matrix.js.map