'use strict';

var ZQFCLTYU_cjs = require('../ZQFCLTYU.cjs');
var _7ZH64OYR_cjs = require('../7ZH64OYR.cjs');
var OT5L7ME6_cjs = require('../OT5L7ME6.cjs');
var OWTMHDOF_cjs = require('../OWTMHDOF.cjs');
var HN3U775J_cjs = require('../HN3U775J.cjs');
require('../7WVEMAKW.cjs');
var F7OAIAEX_cjs = require('../F7OAIAEX.cjs');
var P5BPMTGP_cjs = require('../P5BPMTGP.cjs');
require('../WDSPHVPJ.cjs');
var JGLHYXTW_cjs = require('../JGLHYXTW.cjs');
var _36UU6CJU_cjs = require('../36UU6CJU.cjs');
var FOFSZBOK_cjs = require('../FOFSZBOK.cjs');
require('../PUL6NSHI.cjs');
var KSZMBVFB_cjs = require('../KSZMBVFB.cjs');
var U7VZULNU_cjs = require('../U7VZULNU.cjs');
var commander = require('commander');
var path = require('path');
var process$1 = require('process');

// src/scripts/generate-github-matrix.ts
U7VZULNU_cjs.init_cjs_shims();

// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/ECRClient.js
U7VZULNU_cjs.init_cjs_shims();

// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/auth/httpAuthSchemeProvider.js
U7VZULNU_cjs.init_cjs_shims();
var defaultECRHttpAuthSchemeParametersProvider = /* @__PURE__ */ U7VZULNU_cjs.__name(async (config, context, input) => {
  return {
    operation: _7ZH64OYR_cjs.getSmithyContext(context).operation,
    region: await _7ZH64OYR_cjs.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__ */ U7VZULNU_cjs.__name((config, context) => ({
      signingProperties: {
        config,
        context
      }
    }), "propertiesExtractor")
  };
}
U7VZULNU_cjs.__name(createAwsAuthSigv4HttpAuthOption, "createAwsAuthSigv4HttpAuthOption");
var defaultECRHttpAuthSchemeProvider = /* @__PURE__ */ U7VZULNU_cjs.__name((authParameters) => {
  const options = [];
  switch (authParameters.operation) {
    default: {
      options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
    }
  }
  return options;
}, "defaultECRHttpAuthSchemeProvider");
var resolveHttpAuthSchemeConfig = /* @__PURE__ */ U7VZULNU_cjs.__name((config) => {
  const config_0 = _7ZH64OYR_cjs.resolveAwsSdkSigV4Config(config);
  return Object.assign(config_0, {
    authSchemePreference: _7ZH64OYR_cjs.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
U7VZULNU_cjs.init_cjs_shims();
var resolveClientEndpointParameters = /* @__PURE__ */ U7VZULNU_cjs.__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/dist-es/runtimeConfig.js
U7VZULNU_cjs.init_cjs_shims();

// ../../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/index.js
U7VZULNU_cjs.init_cjs_shims();

// ../../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.879.0/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
U7VZULNU_cjs.init_cjs_shims();

// ../../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.879.0/node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js
U7VZULNU_cjs.init_cjs_shims();
var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
var remoteProvider = /* @__PURE__ */ U7VZULNU_cjs.__name(async (init) => {
  const { ENV_CMDS_FULL_URI, ENV_CMDS_RELATIVE_URI, fromContainerMetadata, fromInstanceMetadata } = await import('../HMP4FGDB.cjs');
  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('../4SZ6P77Q.cjs');
    return JGLHYXTW_cjs.chain(fromHttp(init), fromContainerMetadata(init));
  }
  if (process.env[ENV_IMDS_DISABLED] && process.env[ENV_IMDS_DISABLED] !== "false") {
    return async () => {
      throw new JGLHYXTW_cjs.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__ */ U7VZULNU_cjs.__name((init = {}) => JGLHYXTW_cjs.memoize(JGLHYXTW_cjs.chain(async () => {
  const profile = init.profile ?? process.env[P5BPMTGP_cjs.ENV_PROFILE];
  if (profile) {
    const envStaticCredentialsAreSet = process.env[HN3U775J_cjs.ENV_KEY] && process.env[HN3U775J_cjs.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 JGLHYXTW_cjs.CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", {
      logger: init.logger,
      tryNextLink: true
    });
  }
  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv");
  return HN3U775J_cjs.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 JGLHYXTW_cjs.CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", {
      logger: init.logger
    });
  }
  const { fromSSO } = await import('../MQTCD42Y.cjs');
  return fromSSO(init)();
}, async () => {
  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni");
  const { fromIni } = await import('../BVXMXRYL.cjs');
  return fromIni(init)();
}, async () => {
  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess");
  const { fromProcess } = await import('../LH4V3GFX.cjs');
  return fromProcess(init)();
}, async () => {
  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile");
  const { fromTokenFile } = await import('../4CTWHZA4.cjs');
  return fromTokenFile(init)();
}, async () => {
  init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider");
  return (await remoteProvider(init))();
}, async () => {
  throw new JGLHYXTW_cjs.CredentialsProviderError("Could not load credentials from any providers", {
    tryNextLink: false,
    logger: init.logger
  });
}), credentialsTreatedAsExpired, credentialsWillNeedRefresh), "defaultProvider");
var credentialsWillNeedRefresh = /* @__PURE__ */ U7VZULNU_cjs.__name((credentials) => credentials?.expiration !== void 0, "credentialsWillNeedRefresh");
var credentialsTreatedAsExpired = /* @__PURE__ */ U7VZULNU_cjs.__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/runtimeConfig.shared.js
U7VZULNU_cjs.init_cjs_shims();

// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/endpoint/endpointResolver.js
U7VZULNU_cjs.init_cjs_shims();

// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/endpoint/ruleset.js
U7VZULNU_cjs.init_cjs_shims();
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 _7ZH64OYR_cjs.EndpointCache({
  size: 50,
  params: [
    "Endpoint",
    "Region",
    "UseDualStack",
    "UseFIPS"
  ]
});
var defaultEndpointResolver = /* @__PURE__ */ U7VZULNU_cjs.__name((endpointParams, context = {}) => {
  return cache.get(endpointParams, () => _7ZH64OYR_cjs.resolveEndpoint(ruleSet, {
    endpointParams,
    logger: context.logger
  }));
}, "defaultEndpointResolver");
_7ZH64OYR_cjs.customEndpointFunctions.aws = _7ZH64OYR_cjs.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__ */ U7VZULNU_cjs.__name((config) => {
  return {
    apiVersion: "2015-09-21",
    base64Decoder: config?.base64Decoder ?? OT5L7ME6_cjs.fromBase64,
    base64Encoder: config?.base64Encoder ?? OT5L7ME6_cjs.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__ */ U7VZULNU_cjs.__name((ipc) => ipc.getIdentityProvider("aws.auth#sigv4"), "identityProvider"),
        signer: new _7ZH64OYR_cjs.AwsSdkSigV4Signer()
      }
    ],
    logger: config?.logger ?? new OT5L7ME6_cjs.NoOpLogger(),
    serviceId: config?.serviceId ?? "ECR",
    urlParser: config?.urlParser ?? F7OAIAEX_cjs.parseUrl,
    utf8Decoder: config?.utf8Decoder ?? OWTMHDOF_cjs.fromUtf8,
    utf8Encoder: config?.utf8Encoder ?? OWTMHDOF_cjs.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__ */ U7VZULNU_cjs.__name((config) => {
  OT5L7ME6_cjs.emitWarningIfUnsupportedVersion(process.version);
  const defaultsMode = _7ZH64OYR_cjs.resolveDefaultsModeConfig(config);
  const defaultConfigProvider = /* @__PURE__ */ U7VZULNU_cjs.__name(() => defaultsMode().then(OT5L7ME6_cjs.loadConfigsForDefaultMode), "defaultConfigProvider");
  const clientSharedValues = getRuntimeConfig(config);
  _7ZH64OYR_cjs.emitWarningIfUnsupportedVersion(process.version);
  const loaderConfig = {
    profile: config?.profile,
    logger: clientSharedValues.logger
  };
  return {
    ...clientSharedValues,
    ...config,
    runtime: "node",
    defaultsMode,
    authSchemePreference: config?.authSchemePreference ?? F7OAIAEX_cjs.loadConfig(_7ZH64OYR_cjs.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
    bodyLengthChecker: config?.bodyLengthChecker ?? _7ZH64OYR_cjs.calculateBodyLength,
    credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
    defaultUserAgentProvider: config?.defaultUserAgentProvider ?? _7ZH64OYR_cjs.createDefaultUserAgentProvider({
      serviceId: clientSharedValues.serviceId,
      clientVersion: package_default.version
    }),
    maxAttempts: config?.maxAttempts ?? F7OAIAEX_cjs.loadConfig(_7ZH64OYR_cjs.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
    region: config?.region ?? F7OAIAEX_cjs.loadConfig(_7ZH64OYR_cjs.NODE_REGION_CONFIG_OPTIONS, {
      ..._7ZH64OYR_cjs.NODE_REGION_CONFIG_FILE_OPTIONS,
      ...loaderConfig
    }),
    requestHandler: OT5L7ME6_cjs.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
    retryMode: config?.retryMode ?? F7OAIAEX_cjs.loadConfig({
      ..._7ZH64OYR_cjs.NODE_RETRY_MODE_CONFIG_OPTIONS,
      default: /* @__PURE__ */ U7VZULNU_cjs.__name(async () => (await defaultConfigProvider()).retryMode || _7ZH64OYR_cjs.DEFAULT_RETRY_MODE, "default")
    }, config),
    sha256: config?.sha256 ?? _7ZH64OYR_cjs.Hash.bind(null, "sha256"),
    streamCollector: config?.streamCollector ?? OT5L7ME6_cjs.streamCollector,
    useDualstackEndpoint: config?.useDualstackEndpoint ?? F7OAIAEX_cjs.loadConfig(_7ZH64OYR_cjs.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
    useFipsEndpoint: config?.useFipsEndpoint ?? F7OAIAEX_cjs.loadConfig(_7ZH64OYR_cjs.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
    userAgentAppId: config?.userAgentAppId ?? F7OAIAEX_cjs.loadConfig(_7ZH64OYR_cjs.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/runtimeExtensions.js
U7VZULNU_cjs.init_cjs_shims();

// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/auth/httpAuthExtensionConfiguration.js
U7VZULNU_cjs.init_cjs_shims();
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ U7VZULNU_cjs.__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__ */ U7VZULNU_cjs.__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__ */ U7VZULNU_cjs.__name((runtimeConfig, extensions) => {
  const extensionConfiguration = Object.assign(_7ZH64OYR_cjs.getAwsRegionExtensionConfiguration(runtimeConfig), OT5L7ME6_cjs.getDefaultExtensionConfiguration(runtimeConfig), OT5L7ME6_cjs.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
  extensions.forEach((extension) => extension.configure(extensionConfiguration));
  return Object.assign(runtimeConfig, _7ZH64OYR_cjs.resolveAwsRegionExtensionConfiguration(extensionConfiguration), OT5L7ME6_cjs.resolveDefaultRuntimeConfig(extensionConfiguration), OT5L7ME6_cjs.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 OT5L7ME6_cjs.Client {
  static {
    U7VZULNU_cjs.__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 = _7ZH64OYR_cjs.resolveUserAgentConfig(_config_1);
    const _config_3 = _7ZH64OYR_cjs.resolveRetryConfig(_config_2);
    const _config_4 = _7ZH64OYR_cjs.resolveRegionConfig(_config_3);
    const _config_5 = _7ZH64OYR_cjs.resolveHostHeaderConfig(_config_4);
    const _config_6 = _7ZH64OYR_cjs.resolveEndpointConfig(_config_5);
    const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
    this.config = _config_8;
    this.middlewareStack.use(_7ZH64OYR_cjs.getUserAgentPlugin(this.config));
    this.middlewareStack.use(_7ZH64OYR_cjs.getRetryPlugin(this.config));
    this.middlewareStack.use(_7ZH64OYR_cjs.getContentLengthPlugin(this.config));
    this.middlewareStack.use(_7ZH64OYR_cjs.getHostHeaderPlugin(this.config));
    this.middlewareStack.use(_7ZH64OYR_cjs.getLoggerPlugin(this.config));
    this.middlewareStack.use(_7ZH64OYR_cjs.getRecursionDetectionPlugin(this.config));
    this.middlewareStack.use(_7ZH64OYR_cjs.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
      httpAuthSchemeParametersProvider: defaultECRHttpAuthSchemeParametersProvider,
      identityProviderConfigProvider: /* @__PURE__ */ U7VZULNU_cjs.__name(async (config) => new _7ZH64OYR_cjs.DefaultIdentityProviderConfig({
        "aws.auth#sigv4": config.credentials
      }), "identityProviderConfigProvider")
    }));
    this.middlewareStack.use(_7ZH64OYR_cjs.getHttpSigningPlugin(this.config));
  }
  destroy() {
    super.destroy();
  }
};

// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/protocols/Aws_json1_1.js
U7VZULNU_cjs.init_cjs_shims();

// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/models/ECRServiceException.js
U7VZULNU_cjs.init_cjs_shims();
var ECRServiceException = class _ECRServiceException extends OT5L7ME6_cjs.ServiceException {
  static {
    U7VZULNU_cjs.__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
U7VZULNU_cjs.init_cjs_shims();
var InvalidParameterException = class _InvalidParameterException extends ECRServiceException {
  static {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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 {
    U7VZULNU_cjs.__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__ */ U7VZULNU_cjs.__name(async (input, context) => {
  const headers = sharedHeaders("ListImages");
  let body;
  body = JSON.stringify(OT5L7ME6_cjs._json(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListImagesCommand");
var de_ListImagesCommand = /* @__PURE__ */ U7VZULNU_cjs.__name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await ZQFCLTYU_cjs.parseJsonBody(output.body, context);
  let contents = {};
  contents = OT5L7ME6_cjs._json(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListImagesCommand");
var de_CommandError = /* @__PURE__ */ U7VZULNU_cjs.__name(async (output, context) => {
  const parsedOutput = {
    ...output,
    body: await ZQFCLTYU_cjs.parseJsonErrorBody(output.body, context)
  };
  const errorCode = ZQFCLTYU_cjs.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__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new EmptyUploadException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_EmptyUploadExceptionRes");
var de_ImageAlreadyExistsExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new ImageAlreadyExistsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_ImageAlreadyExistsExceptionRes");
var de_ImageDigestDoesNotMatchExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new ImageDigestDoesNotMatchException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_ImageDigestDoesNotMatchExceptionRes");
var de_ImageNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new ImageNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_ImageNotFoundExceptionRes");
var de_ImageTagAlreadyExistsExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new ImageTagAlreadyExistsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_ImageTagAlreadyExistsExceptionRes");
var de_InvalidLayerExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new InvalidLayerException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_InvalidLayerExceptionRes");
var de_InvalidLayerPartExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new InvalidLayerPartException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_InvalidLayerPartExceptionRes");
var de_InvalidParameterExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new InvalidParameterException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_InvalidParameterExceptionRes");
var de_InvalidTagParameterExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new InvalidTagParameterException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_InvalidTagParameterExceptionRes");
var de_KmsExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new KmsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_KmsExceptionRes");
var de_LayerAlreadyExistsExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new LayerAlreadyExistsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_LayerAlreadyExistsExceptionRes");
var de_LayerInaccessibleExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new LayerInaccessibleException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_LayerInaccessibleExceptionRes");
var de_LayerPartTooSmallExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new LayerPartTooSmallException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_LayerPartTooSmallExceptionRes");
var de_LayersNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new LayersNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_LayersNotFoundExceptionRes");
var de_LifecyclePolicyNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new LifecyclePolicyNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_LifecyclePolicyNotFoundExceptionRes");
var de_LifecyclePolicyPreviewInProgressExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new LifecyclePolicyPreviewInProgressException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_LifecyclePolicyPreviewInProgressExceptionRes");
var de_LifecyclePolicyPreviewNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new LifecyclePolicyPreviewNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_LifecyclePolicyPreviewNotFoundExceptionRes");
var de_LimitExceededExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new LimitExceededException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_LimitExceededExceptionRes");
var de_PullThroughCacheRuleAlreadyExistsExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new PullThroughCacheRuleAlreadyExistsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_PullThroughCacheRuleAlreadyExistsExceptionRes");
var de_PullThroughCacheRuleNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new PullThroughCacheRuleNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_PullThroughCacheRuleNotFoundExceptionRes");
var de_ReferencedImagesNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new ReferencedImagesNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_ReferencedImagesNotFoundExceptionRes");
var de_RegistryPolicyNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new RegistryPolicyNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_RegistryPolicyNotFoundExceptionRes");
var de_RepositoryAlreadyExistsExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new RepositoryAlreadyExistsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_RepositoryAlreadyExistsExceptionRes");
var de_RepositoryNotEmptyExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new RepositoryNotEmptyException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_RepositoryNotEmptyExceptionRes");
var de_RepositoryNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new RepositoryNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_RepositoryNotFoundExceptionRes");
var de_RepositoryPolicyNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new RepositoryPolicyNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_RepositoryPolicyNotFoundExceptionRes");
var de_ScanNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new ScanNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_ScanNotFoundExceptionRes");
var de_SecretNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new SecretNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_SecretNotFoundExceptionRes");
var de_ServerExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new ServerException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_ServerExceptionRes");
var de_TemplateAlreadyExistsExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new TemplateAlreadyExistsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_TemplateAlreadyExistsExceptionRes");
var de_TemplateNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new TemplateNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_TemplateNotFoundExceptionRes");
var de_TooManyTagsExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new TooManyTagsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_TooManyTagsExceptionRes");
var de_UnableToAccessSecretExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new UnableToAccessSecretException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_UnableToAccessSecretExceptionRes");
var de_UnableToDecryptSecretValueExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new UnableToDecryptSecretValueException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_UnableToDecryptSecretValueExceptionRes");
var de_UnableToGetUpstreamImageExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new UnableToGetUpstreamImageException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_UnableToGetUpstreamImageExceptionRes");
var de_UnableToGetUpstreamLayerExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new UnableToGetUpstreamLayerException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_UnableToGetUpstreamLayerExceptionRes");
var de_UnsupportedImageTypeExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new UnsupportedImageTypeException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_UnsupportedImageTypeExceptionRes");
var de_UnsupportedUpstreamRegistryExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new UnsupportedUpstreamRegistryException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_UnsupportedUpstreamRegistryExceptionRes");
var de_UploadNotFoundExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new UploadNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_UploadNotFoundExceptionRes");
var de_ValidationExceptionRes = /* @__PURE__ */ U7VZULNU_cjs.__name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = OT5L7ME6_cjs._json(body);
  const exception = new ValidationException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return OT5L7ME6_cjs.decorateServiceException(exception, body);
}, "de_ValidationExceptionRes");
var deserializeMetadata = /* @__PURE__ */ U7VZULNU_cjs.__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 = OT5L7ME6_cjs.withBaseException(ECRServiceException);
var buildHttpRpcRequest = /* @__PURE__ */ U7VZULNU_cjs.__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 OT5L7ME6_cjs.HttpRequest(contents);
}, "buildHttpRpcRequest");
function sharedHeaders(operation) {
  return {
    "content-type": "application/x-amz-json-1.1",
    "x-amz-target": `AmazonEC2ContainerRegistry_V20150921.${operation}`
  };
}
U7VZULNU_cjs.__name(sharedHeaders, "sharedHeaders");

// ../../node_modules/.pnpm/@aws-sdk+client-ecr@3.879.0/node_modules/@aws-sdk/client-ecr/dist-es/commands/ListImagesCommand.js
U7VZULNU_cjs.init_cjs_shims();
var ListImagesCommand = class extends OT5L7ME6_cjs.Command.classBuilder().ep(commonParams).m(function(Command3, cs, config, o2) {
  return [
    _7ZH64OYR_cjs.getSerdePlugin(config, this.serialize, this.deserialize),
    _7ZH64OYR_cjs.getEndpointPlugin(config, Command3.getEndpointParameterInstructions())
  ];
}).s("AmazonEC2ContainerRegistry_V20150921", "ListImages", {}).n("ECRClient", "ListImagesCommand").f(void 0, void 0).ser(se_ListImagesCommand).de(de_ListImagesCommand).build() {
  static {
    U7VZULNU_cjs.__name(this, "ListImagesCommand");
  }
};
var tagSeparators = [
  "-",
  "_"
];
var ecrClient = new ECRClient();
var command = new commander.Command().name("generate-github-matrix").requiredOption("--registry <registry>").parse();
var { registry } = command.opts();
var compileImage = /* @__PURE__ */ U7VZULNU_cjs.__name(async (image) => {
  const repository = path.join(FOFSZBOK_cjs.ECR_IMAGE_DIRECTORY, FOFSZBOK_cjs.getImageName(image.name));
  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.warn(error.message);
  }
  console.warn(`Existing tags for ${repository}:`, [
    ...existingTags
  ]);
  const tags = tagSeparators.map((separator) => `${registry}/${repository}:${_36UU6CJU_cjs.getImageTag(image, separator)}`);
  if (tags.some((tag) => existingTags.has(tag.split(":").at(-1)))) {
    return null;
  }
  return {
    name: image.name,
    build_args: Object.entries(image.versions).sort().map(([key, value]) => `${key.replaceAll("-", "_").toUpperCase()}_VERSION=${value}`),
    directory: path.join("tools/vm-tooling/docker", image.name),
    repository,
    tags
  };
}, "compileImage");
var main = /* @__PURE__ */ U7VZULNU_cjs.__name(async () => {
  const entries = (await Promise.all(Object.values(KSZMBVFB_cjs.images).map(compileImage))).filter((entry) => !!entry);
  console.warn("GitHub Action matrix generated:", entries);
  process$1.stdout.write(JSON.stringify(entries));
}, "main");
if (undefined) {
  main().catch((error) => {
    console.error(error);
    process.exit(1);
  });
}
//# sourceMappingURL=generate-github-matrix.cjs.map
//# sourceMappingURL=generate-github-matrix.cjs.map