@etainabl/nodejs-sdk 1.3.192 → 1.3.196

package/dist/esm/chunk-4QSQRVYQ.js

@@ -1,4408 +0,0 @@
-import {
-  loadConfig,
-  memoize,
-  parseUrl
-} from "./chunk-3G3VXGQN.js";
-import {
-  HttpRequest,
-  HttpResponse,
-  escapeUri,
-  fromBase64,
-  fromHex,
-  toBase64,
-  toHex
-} from "./chunk-D74LA2XQ.js";
-import {
-  fromArrayBuffer,
-  fromString,
-  fromUtf8,
-  isArrayBuffer,
-  toUtf8
-} from "./chunk-Z63CAAFL.js";
-import {
-  CONFIG_PREFIX_SEPARATOR
-} from "./chunk-CRX53WMM.js";
-import {
-  setCredentialFeature
-} from "./chunk-UZGMBQZB.js";
-import {
-  ProviderError
-} from "./chunk-IX2LY325.js";
-
-// node_modules/@smithy/middleware-stack/dist-es/MiddlewareStack.js
-var getAllAliases = (name, aliases) => {
-  const _aliases = [];
-  if (name) {
-    _aliases.push(name);
-  }
-  if (aliases) {
-    for (const alias of aliases) {
-      _aliases.push(alias);
-    }
-  }
-  return _aliases;
-};
-var getMiddlewareNameWithAliases = (name, aliases) => {
-  return `${name || "anonymous"}${aliases && aliases.length > 0 ? ` (a.k.a. ${aliases.join(",")})` : ""}`;
-};
-var constructStack = () => {
-  let absoluteEntries = [];
-  let relativeEntries = [];
-  let identifyOnResolve = false;
-  const entriesNameSet = /* @__PURE__ */ new Set();
-  const sort = (entries) => entries.sort((a, b) => stepWeights[b.step] - stepWeights[a.step] || priorityWeights[b.priority || "normal"] - priorityWeights[a.priority || "normal"]);
-  const removeByName = (toRemove) => {
-    let isRemoved = false;
-    const filterCb = (entry) => {
-      const aliases = getAllAliases(entry.name, entry.aliases);
-      if (aliases.includes(toRemove)) {
-        isRemoved = true;
-        for (const alias of aliases) {
-          entriesNameSet.delete(alias);
-        }
-        return false;
-      }
-      return true;
-    };
-    absoluteEntries = absoluteEntries.filter(filterCb);
-    relativeEntries = relativeEntries.filter(filterCb);
-    return isRemoved;
-  };
-  const removeByReference = (toRemove) => {
-    let isRemoved = false;
-    const filterCb = (entry) => {
-      if (entry.middleware === toRemove) {
-        isRemoved = true;
-        for (const alias of getAllAliases(entry.name, entry.aliases)) {
-          entriesNameSet.delete(alias);
-        }
-        return false;
-      }
-      return true;
-    };
-    absoluteEntries = absoluteEntries.filter(filterCb);
-    relativeEntries = relativeEntries.filter(filterCb);
-    return isRemoved;
-  };
-  const cloneTo = (toStack) => {
-    absoluteEntries.forEach((entry) => {
-      toStack.add(entry.middleware, { ...entry });
-    });
-    relativeEntries.forEach((entry) => {
-      toStack.addRelativeTo(entry.middleware, { ...entry });
-    });
-    toStack.identifyOnResolve?.(stack.identifyOnResolve());
-    return toStack;
-  };
-  const expandRelativeMiddlewareList = (from) => {
-    const expandedMiddlewareList = [];
-    from.before.forEach((entry) => {
-      if (entry.before.length === 0 && entry.after.length === 0) {
-        expandedMiddlewareList.push(entry);
-      } else {
-        expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
-      }
-    });
-    expandedMiddlewareList.push(from);
-    from.after.reverse().forEach((entry) => {
-      if (entry.before.length === 0 && entry.after.length === 0) {
-        expandedMiddlewareList.push(entry);
-      } else {
-        expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
-      }
-    });
-    return expandedMiddlewareList;
-  };
-  const getMiddlewareList = (debug = false) => {
-    const normalizedAbsoluteEntries = [];
-    const normalizedRelativeEntries = [];
-    const normalizedEntriesNameMap = {};
-    absoluteEntries.forEach((entry) => {
-      const normalizedEntry = {
-        ...entry,
-        before: [],
-        after: []
-      };
-      for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
-        normalizedEntriesNameMap[alias] = normalizedEntry;
-      }
-      normalizedAbsoluteEntries.push(normalizedEntry);
-    });
-    relativeEntries.forEach((entry) => {
-      const normalizedEntry = {
-        ...entry,
-        before: [],
-        after: []
-      };
-      for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
-        normalizedEntriesNameMap[alias] = normalizedEntry;
-      }
-      normalizedRelativeEntries.push(normalizedEntry);
-    });
-    normalizedRelativeEntries.forEach((entry) => {
-      if (entry.toMiddleware) {
-        const toMiddleware = normalizedEntriesNameMap[entry.toMiddleware];
-        if (toMiddleware === void 0) {
-          if (debug) {
-            return;
-          }
-          throw new Error(`${entry.toMiddleware} is not found when adding ${getMiddlewareNameWithAliases(entry.name, entry.aliases)} middleware ${entry.relation} ${entry.toMiddleware}`);
-        }
-        if (entry.relation === "after") {
-          toMiddleware.after.push(entry);
-        }
-        if (entry.relation === "before") {
-          toMiddleware.before.push(entry);
-        }
-      }
-    });
-    const mainChain = sort(normalizedAbsoluteEntries).map(expandRelativeMiddlewareList).reduce((wholeList, expandedMiddlewareList) => {
-      wholeList.push(...expandedMiddlewareList);
-      return wholeList;
-    }, []);
-    return mainChain;
-  };
-  const stack = {
-    add: (middleware, options = {}) => {
-      const { name, override, aliases: _aliases } = options;
-      const entry = {
-        step: "initialize",
-        priority: "normal",
-        middleware,
-        ...options
-      };
-      const aliases = getAllAliases(name, _aliases);
-      if (aliases.length > 0) {
-        if (aliases.some((alias) => entriesNameSet.has(alias))) {
-          if (!override)
-            throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`);
-          for (const alias of aliases) {
-            const toOverrideIndex = absoluteEntries.findIndex((entry2) => entry2.name === alias || entry2.aliases?.some((a) => a === alias));
-            if (toOverrideIndex === -1) {
-              continue;
-            }
-            const toOverride = absoluteEntries[toOverrideIndex];
-            if (toOverride.step !== entry.step || entry.priority !== toOverride.priority) {
-              throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware with ${toOverride.priority} priority in ${toOverride.step} step cannot be overridden by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware with ${entry.priority} priority in ${entry.step} step.`);
-            }
-            absoluteEntries.splice(toOverrideIndex, 1);
-          }
-        }
-        for (const alias of aliases) {
-          entriesNameSet.add(alias);
-        }
-      }
-      absoluteEntries.push(entry);
-    },
-    addRelativeTo: (middleware, options) => {
-      const { name, override, aliases: _aliases } = options;
-      const entry = {
-        middleware,
-        ...options
-      };
-      const aliases = getAllAliases(name, _aliases);
-      if (aliases.length > 0) {
-        if (aliases.some((alias) => entriesNameSet.has(alias))) {
-          if (!override)
-            throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`);
-          for (const alias of aliases) {
-            const toOverrideIndex = relativeEntries.findIndex((entry2) => entry2.name === alias || entry2.aliases?.some((a) => a === alias));
-            if (toOverrideIndex === -1) {
-              continue;
-            }
-            const toOverride = relativeEntries[toOverrideIndex];
-            if (toOverride.toMiddleware !== entry.toMiddleware || toOverride.relation !== entry.relation) {
-              throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware ${toOverride.relation} "${toOverride.toMiddleware}" middleware cannot be overridden by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware ${entry.relation} "${entry.toMiddleware}" middleware.`);
-            }
-            relativeEntries.splice(toOverrideIndex, 1);
-          }
-        }
-        for (const alias of aliases) {
-          entriesNameSet.add(alias);
-        }
-      }
-      relativeEntries.push(entry);
-    },
-    clone: () => cloneTo(constructStack()),
-    use: (plugin) => {
-      plugin.applyToStack(stack);
-    },
-    remove: (toRemove) => {
-      if (typeof toRemove === "string")
-        return removeByName(toRemove);
-      else
-        return removeByReference(toRemove);
-    },
-    removeByTag: (toRemove) => {
-      let isRemoved = false;
-      const filterCb = (entry) => {
-        const { tags, name, aliases: _aliases } = entry;
-        if (tags && tags.includes(toRemove)) {
-          const aliases = getAllAliases(name, _aliases);
-          for (const alias of aliases) {
-            entriesNameSet.delete(alias);
-          }
-          isRemoved = true;
-          return false;
-        }
-        return true;
-      };
-      absoluteEntries = absoluteEntries.filter(filterCb);
-      relativeEntries = relativeEntries.filter(filterCb);
-      return isRemoved;
-    },
-    concat: (from) => {
-      const cloned = cloneTo(constructStack());
-      cloned.use(from);
-      cloned.identifyOnResolve(identifyOnResolve || cloned.identifyOnResolve() || (from.identifyOnResolve?.() ?? false));
-      return cloned;
-    },
-    applyToStack: cloneTo,
-    identify: () => {
-      return getMiddlewareList(true).map((mw) => {
-        const step = mw.step ?? mw.relation + " " + mw.toMiddleware;
-        return getMiddlewareNameWithAliases(mw.name, mw.aliases) + " - " + step;
-      });
-    },
-    identifyOnResolve(toggle) {
-      if (typeof toggle === "boolean")
-        identifyOnResolve = toggle;
-      return identifyOnResolve;
-    },
-    resolve: (handler, context) => {
-      for (const middleware of getMiddlewareList().map((entry) => entry.middleware).reverse()) {
-        handler = middleware(handler, context);
-      }
-      if (identifyOnResolve) {
-        console.log(stack.identify());
-      }
-      return handler;
-    }
-  };
-  return stack;
-};
-var stepWeights = {
-  initialize: 5,
-  serialize: 4,
-  build: 3,
-  finalizeRequest: 2,
-  deserialize: 1
-};
-var priorityWeights = {
-  high: 3,
-  normal: 2,
-  low: 1
-};
-
-// node_modules/@smithy/smithy-client/dist-es/client.js
-var Client = class {
-  config;
-  middlewareStack = constructStack();
-  initConfig;
-  handlers;
-  constructor(config) {
-    this.config = config;
-    const { protocol, protocolSettings } = config;
-    if (protocolSettings) {
-      if (typeof protocol === "function") {
-        config.protocol = new protocol(protocolSettings);
-      }
-    }
-  }
-  send(command, optionsOrCb, cb) {
-    const options = typeof optionsOrCb !== "function" ? optionsOrCb : void 0;
-    const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
-    const useHandlerCache = options === void 0 && this.config.cacheMiddleware === true;
-    let handler;
-    if (useHandlerCache) {
-      if (!this.handlers) {
-        this.handlers = /* @__PURE__ */ new WeakMap();
-      }
-      const handlers = this.handlers;
-      if (handlers.has(command.constructor)) {
-        handler = handlers.get(command.constructor);
-      } else {
-        handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
-        handlers.set(command.constructor, handler);
-      }
-    } else {
-      delete this.handlers;
-      handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
-    }
-    if (callback) {
-      handler(command).then((result) => callback(null, result.output), (err) => callback(err)).catch(() => {
-      });
-    } else {
-      return handler(command).then((result) => result.output);
-    }
-  }
-  destroy() {
-    this.config?.requestHandler?.destroy?.();
-    delete this.handlers;
-  }
-};
-
-// node_modules/@smithy/types/dist-es/endpoint.js
-var EndpointURLScheme;
-(function(EndpointURLScheme2) {
-  EndpointURLScheme2["HTTP"] = "http";
-  EndpointURLScheme2["HTTPS"] = "https";
-})(EndpointURLScheme || (EndpointURLScheme = {}));
-
-// node_modules/@smithy/types/dist-es/extensions/checksum.js
-var AlgorithmId;
-(function(AlgorithmId2) {
-  AlgorithmId2["MD5"] = "md5";
-  AlgorithmId2["CRC32"] = "crc32";
-  AlgorithmId2["CRC32C"] = "crc32c";
-  AlgorithmId2["SHA1"] = "sha1";
-  AlgorithmId2["SHA256"] = "sha256";
-})(AlgorithmId || (AlgorithmId = {}));
-
-// node_modules/@smithy/types/dist-es/middleware.js
-var SMITHY_CONTEXT_KEY = "__smithy_context";
-
-// node_modules/@smithy/core/dist-es/submodules/schema/deref.js
-var deref = (schemaRef) => {
-  if (typeof schemaRef === "function") {
-    return schemaRef();
-  }
-  return schemaRef;
-};
-
-// node_modules/@smithy/protocol-http/dist-es/extensions/httpExtensionConfiguration.js
-var getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
-  return {
-    setHttpHandler(handler) {
-      runtimeConfig.httpHandler = handler;
-    },
-    httpHandler() {
-      return runtimeConfig.httpHandler;
-    },
-    updateHttpClientConfig(key, value) {
-      runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
-    },
-    httpHandlerConfigs() {
-      return runtimeConfig.httpHandler.httpHandlerConfigs();
-    }
-  };
-};
-var resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
-  return {
-    httpHandler: httpHandlerExtensionConfiguration.httpHandler()
-  };
-};
-
-// node_modules/@smithy/util-middleware/dist-es/getSmithyContext.js
-var getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
-
-// node_modules/@smithy/util-middleware/dist-es/normalizeProvider.js
-var normalizeProvider = (input) => {
-  if (typeof input === "function")
-    return input;
-  const promisified = Promise.resolve(input);
-  return () => promisified;
-};
-
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/translateTraits.js
-function translateTraits(indicator) {
-  if (typeof indicator === "object") {
-    return indicator;
-  }
-  indicator = indicator | 0;
-  const traits = {};
-  let i = 0;
-  for (const trait of [
-    "httpLabel",
-    "idempotent",
-    "idempotencyToken",
-    "sensitive",
-    "httpPayload",
-    "httpResponseCode",
-    "httpQueryParams"
-  ]) {
-    if ((indicator >> i++ & 1) === 1) {
-      traits[trait] = 1;
-    }
-  }
-  return traits;
-}
-
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js
-var NormalizedSchema = class _NormalizedSchema {
-  ref;
-  memberName;
-  static symbol = Symbol.for("@smithy/nor");
-  symbol = _NormalizedSchema.symbol;
-  name;
-  schema;
-  _isMemberSchema;
-  traits;
-  memberTraits;
-  normalizedTraits;
-  constructor(ref, memberName) {
-    this.ref = ref;
-    this.memberName = memberName;
-    const traitStack = [];
-    let _ref = ref;
-    let schema = ref;
-    this._isMemberSchema = false;
-    while (isMemberSchema(_ref)) {
-      traitStack.push(_ref[1]);
-      _ref = _ref[0];
-      schema = deref(_ref);
-      this._isMemberSchema = true;
-    }
-    if (traitStack.length > 0) {
-      this.memberTraits = {};
-      for (let i = traitStack.length - 1; i >= 0; --i) {
-        const traitSet = traitStack[i];
-        Object.assign(this.memberTraits, translateTraits(traitSet));
-      }
-    } else {
-      this.memberTraits = 0;
-    }
-    if (schema instanceof _NormalizedSchema) {
-      const computedMemberTraits = this.memberTraits;
-      Object.assign(this, schema);
-      this.memberTraits = Object.assign({}, computedMemberTraits, schema.getMemberTraits(), this.getMemberTraits());
-      this.normalizedTraits = void 0;
-      this.memberName = memberName ?? schema.memberName;
-      return;
-    }
-    this.schema = deref(schema);
-    if (isStaticSchema(this.schema)) {
-      this.name = `${this.schema[1]}#${this.schema[2]}`;
-      this.traits = this.schema[3];
-    } else {
-      this.name = this.memberName ?? String(schema);
-      this.traits = 0;
-    }
-    if (this._isMemberSchema && !memberName) {
-      throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
-    }
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = this.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const ns = lhs;
-      return ns.symbol === this.symbol;
-    }
-    return isPrototype;
-  }
-  static of(ref) {
-    const sc = deref(ref);
-    if (sc instanceof _NormalizedSchema) {
-      return sc;
-    }
-    if (isMemberSchema(sc)) {
-      const [ns, traits] = sc;
-      if (ns instanceof _NormalizedSchema) {
-        Object.assign(ns.getMergedTraits(), translateTraits(traits));
-        return ns;
-      }
-      throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`);
-    }
-    return new _NormalizedSchema(sc);
-  }
-  getSchema() {
-    const sc = this.schema;
-    if (sc[0] === 0) {
-      return sc[4];
-    }
-    return sc;
-  }
-  getName(withNamespace = false) {
-    const { name } = this;
-    const short = !withNamespace && name && name.includes("#");
-    return short ? name.split("#")[1] : name || void 0;
-  }
-  getMemberName() {
-    return this.memberName;
-  }
-  isMemberSchema() {
-    return this._isMemberSchema;
-  }
-  isListSchema() {
-    const sc = this.getSchema();
-    return typeof sc === "number" ? sc >= 64 && sc < 128 : sc[0] === 1;
-  }
-  isMapSchema() {
-    const sc = this.getSchema();
-    return typeof sc === "number" ? sc >= 128 && sc <= 255 : sc[0] === 2;
-  }
-  isStructSchema() {
-    const sc = this.getSchema();
-    const id = sc[0];
-    return id === 3 || id === -3 || id === 4;
-  }
-  isUnionSchema() {
-    const sc = this.getSchema();
-    return sc[0] === 4;
-  }
-  isBlobSchema() {
-    const sc = this.getSchema();
-    return sc === 21 || sc === 42;
-  }
-  isTimestampSchema() {
-    const sc = this.getSchema();
-    return typeof sc === "number" && sc >= 4 && sc <= 7;
-  }
-  isUnitSchema() {
-    return this.getSchema() === "unit";
-  }
-  isDocumentSchema() {
-    return this.getSchema() === 15;
-  }
-  isStringSchema() {
-    return this.getSchema() === 0;
-  }
-  isBooleanSchema() {
-    return this.getSchema() === 2;
-  }
-  isNumericSchema() {
-    return this.getSchema() === 1;
-  }
-  isBigIntegerSchema() {
-    return this.getSchema() === 17;
-  }
-  isBigDecimalSchema() {
-    return this.getSchema() === 19;
-  }
-  isStreaming() {
-    const { streaming } = this.getMergedTraits();
-    return !!streaming || this.getSchema() === 42;
-  }
-  isIdempotencyToken() {
-    const match = (traits2) => (traits2 & 4) === 4 || !!traits2?.idempotencyToken;
-    const { normalizedTraits, traits, memberTraits } = this;
-    return match(normalizedTraits) || match(traits) || match(memberTraits);
-  }
-  getMergedTraits() {
-    return this.normalizedTraits ?? (this.normalizedTraits = {
-      ...this.getOwnTraits(),
-      ...this.getMemberTraits()
-    });
-  }
-  getMemberTraits() {
-    return translateTraits(this.memberTraits);
-  }
-  getOwnTraits() {
-    return translateTraits(this.traits);
-  }
-  getKeySchema() {
-    const [isDoc, isMap] = [this.isDocumentSchema(), this.isMapSchema()];
-    if (!isDoc && !isMap) {
-      throw new Error(`@smithy/core/schema - cannot get key for non-map: ${this.getName(true)}`);
-    }
-    const schema = this.getSchema();
-    const memberSchema = isDoc ? 15 : schema[4] ?? 0;
-    return member([memberSchema, 0], "key");
-  }
-  getValueSchema() {
-    const sc = this.getSchema();
-    const [isDoc, isMap, isList] = [this.isDocumentSchema(), this.isMapSchema(), this.isListSchema()];
-    const memberSchema = typeof sc === "number" ? 63 & sc : sc && typeof sc === "object" && (isMap || isList) ? sc[3 + sc[0]] : isDoc ? 15 : void 0;
-    if (memberSchema != null) {
-      return member([memberSchema, 0], isMap ? "value" : "member");
-    }
-    throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`);
-  }
-  getMemberSchema(memberName) {
-    const struct = this.getSchema();
-    if (this.isStructSchema() && struct[4].includes(memberName)) {
-      const i = struct[4].indexOf(memberName);
-      const memberSchema = struct[5][i];
-      return member(isMemberSchema(memberSchema) ? memberSchema : [memberSchema, 0], memberName);
-    }
-    if (this.isDocumentSchema()) {
-      return member([15, 0], memberName);
-    }
-    throw new Error(`@smithy/core/schema - ${this.getName(true)} has no no member=${memberName}.`);
-  }
-  getMemberSchemas() {
-    const buffer = {};
-    try {
-      for (const [k, v] of this.structIterator()) {
-        buffer[k] = v;
-      }
-    } catch (ignored) {
-    }
-    return buffer;
-  }
-  getEventStreamMember() {
-    if (this.isStructSchema()) {
-      for (const [memberName, memberSchema] of this.structIterator()) {
-        if (memberSchema.isStreaming() && memberSchema.isStructSchema()) {
-          return memberName;
-        }
-      }
-    }
-    return "";
-  }
-  *structIterator() {
-    if (this.isUnitSchema()) {
-      return;
-    }
-    if (!this.isStructSchema()) {
-      throw new Error("@smithy/core/schema - cannot iterate non-struct schema.");
-    }
-    const struct = this.getSchema();
-    for (let i = 0; i < struct[4].length; ++i) {
-      yield [struct[4][i], member([struct[5][i], 0], struct[4][i])];
-    }
-  }
-};
-function member(memberSchema, memberName) {
-  if (memberSchema instanceof NormalizedSchema) {
-    return Object.assign(memberSchema, {
-      memberName,
-      _isMemberSchema: true
-    });
-  }
-  const internalCtorAccess = NormalizedSchema;
-  return new internalCtorAccess(memberSchema, memberName);
-}
-var isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
-var isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;
-
-// node_modules/@smithy/smithy-client/dist-es/schemaLogFilter.js
-var SENSITIVE_STRING = "***SensitiveInformation***";
-function schemaLogFilter(schema, data) {
-  if (data == null) {
-    return data;
-  }
-  const ns = NormalizedSchema.of(schema);
-  if (ns.getMergedTraits().sensitive) {
-    return SENSITIVE_STRING;
-  }
-  if (ns.isListSchema()) {
-    const isSensitive = !!ns.getValueSchema().getMergedTraits().sensitive;
-    if (isSensitive) {
-      return SENSITIVE_STRING;
-    }
-  } else if (ns.isMapSchema()) {
-    const isSensitive = !!ns.getKeySchema().getMergedTraits().sensitive || !!ns.getValueSchema().getMergedTraits().sensitive;
-    if (isSensitive) {
-      return SENSITIVE_STRING;
-    }
-  } else if (ns.isStructSchema() && typeof data === "object") {
-    const object = data;
-    const newObject = {};
-    for (const [member2, memberNs] of ns.structIterator()) {
-      if (object[member2] != null) {
-        newObject[member2] = schemaLogFilter(memberNs, object[member2]);
-      }
-    }
-    return newObject;
-  }
-  return data;
-}
-
-// node_modules/@smithy/smithy-client/dist-es/command.js
-var Command = class {
-  middlewareStack = constructStack();
-  schema;
-  static classBuilder() {
-    return new ClassBuilder();
-  }
-  resolveMiddlewareWithContext(clientStack, configuration, options, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor }) {
-    for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) {
-      this.middlewareStack.use(mw);
-    }
-    const stack = clientStack.concat(this.middlewareStack);
-    const { logger } = configuration;
-    const handlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog,
-      outputFilterSensitiveLog,
-      [SMITHY_CONTEXT_KEY]: {
-        commandInstance: this,
-        ...smithyContext
-      },
-      ...additionalContext
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-  }
-};
-var ClassBuilder = class {
-  _init = () => {
-  };
-  _ep = {};
-  _middlewareFn = () => [];
-  _commandName = "";
-  _clientName = "";
-  _additionalContext = {};
-  _smithyContext = {};
-  _inputFilterSensitiveLog = void 0;
-  _outputFilterSensitiveLog = void 0;
-  _serializer = null;
-  _deserializer = null;
-  _operationSchema;
-  init(cb) {
-    this._init = cb;
-  }
-  ep(endpointParameterInstructions) {
-    this._ep = endpointParameterInstructions;
-    return this;
-  }
-  m(middlewareSupplier) {
-    this._middlewareFn = middlewareSupplier;
-    return this;
-  }
-  s(service, operation, smithyContext = {}) {
-    this._smithyContext = {
-      service,
-      operation,
-      ...smithyContext
-    };
-    return this;
-  }
-  c(additionalContext = {}) {
-    this._additionalContext = additionalContext;
-    return this;
-  }
-  n(clientName, commandName) {
-    this._clientName = clientName;
-    this._commandName = commandName;
-    return this;
-  }
-  f(inputFilter = (_) => _, outputFilter = (_) => _) {
-    this._inputFilterSensitiveLog = inputFilter;
-    this._outputFilterSensitiveLog = outputFilter;
-    return this;
-  }
-  ser(serializer) {
-    this._serializer = serializer;
-    return this;
-  }
-  de(deserializer) {
-    this._deserializer = deserializer;
-    return this;
-  }
-  sc(operation) {
-    this._operationSchema = operation;
-    this._smithyContext.operationSchema = operation;
-    return this;
-  }
-  build() {
-    const closure = this;
-    let CommandRef;
-    return CommandRef = class extends Command {
-      input;
-      static getEndpointParameterInstructions() {
-        return closure._ep;
-      }
-      constructor(...[input]) {
-        super();
-        this.input = input ?? {};
-        closure._init(this);
-        this.schema = closure._operationSchema;
-      }
-      resolveMiddleware(stack, configuration, options) {
-        const op = closure._operationSchema;
-        const input = op?.[4] ?? op?.input;
-        const output = op?.[5] ?? op?.output;
-        return this.resolveMiddlewareWithContext(stack, configuration, options, {
-          CommandCtor: CommandRef,
-          middlewareFn: closure._middlewareFn,
-          clientName: closure._clientName,
-          commandName: closure._commandName,
-          inputFilterSensitiveLog: closure._inputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, input) : (_) => _),
-          outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, output) : (_) => _),
-          smithyContext: closure._smithyContext,
-          additionalContext: closure._additionalContext
-        });
-      }
-      serialize = closure._serializer;
-      deserialize = closure._deserializer;
-    };
-  }
-};
-
-// node_modules/@aws-sdk/middleware-host-header/dist-es/index.js
-function resolveHostHeaderConfig(input) {
-  return input;
-}
-var hostHeaderMiddleware = (options) => (next) => async (args) => {
-  if (!HttpRequest.isInstance(args.request))
-    return next(args);
-  const { request } = args;
-  const { handlerProtocol = "" } = options.requestHandler.metadata || {};
-  if (handlerProtocol.indexOf("h2") >= 0 && !request.headers[":authority"]) {
-    delete request.headers["host"];
-    request.headers[":authority"] = request.hostname + (request.port ? ":" + request.port : "");
-  } else if (!request.headers["host"]) {
-    let host = request.hostname;
-    if (request.port != null)
-      host += `:${request.port}`;
-    request.headers["host"] = host;
-  }
-  return next(args);
-};
-var hostHeaderMiddlewareOptions = {
-  name: "hostHeaderMiddleware",
-  step: "build",
-  priority: "low",
-  tags: ["HOST"],
-  override: true
-};
-var getHostHeaderPlugin = (options) => ({
-  applyToStack: (clientStack) => {
-    clientStack.add(hostHeaderMiddleware(options), hostHeaderMiddlewareOptions);
-  }
-});
-
-// node_modules/@aws-sdk/middleware-logger/dist-es/loggerMiddleware.js
-var loggerMiddleware = () => (next, context) => async (args) => {
-  try {
-    const response = await next(args);
-    const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
-    const { overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
-    const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
-    const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context.outputFilterSensitiveLog;
-    const { $metadata, ...outputWithoutMetadata } = response.output;
-    logger?.info?.({
-      clientName,
-      commandName,
-      input: inputFilterSensitiveLog(args.input),
-      output: outputFilterSensitiveLog(outputWithoutMetadata),
-      metadata: $metadata
-    });
-    return response;
-  } catch (error) {
-    const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
-    const { overrideInputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
-    const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
-    logger?.error?.({
-      clientName,
-      commandName,
-      input: inputFilterSensitiveLog(args.input),
-      error,
-      metadata: error.$metadata
-    });
-    throw error;
-  }
-};
-var loggerMiddlewareOptions = {
-  name: "loggerMiddleware",
-  tags: ["LOGGER"],
-  step: "initialize",
-  override: true
-};
-var getLoggerPlugin = (options) => ({
-  applyToStack: (clientStack) => {
-    clientStack.add(loggerMiddleware(), loggerMiddlewareOptions);
-  }
-});
-
-// node_modules/@aws-sdk/middleware-recursion-detection/dist-es/index.js
-var TRACE_ID_HEADER_NAME = "X-Amzn-Trace-Id";
-var ENV_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME";
-var ENV_TRACE_ID = "_X_AMZN_TRACE_ID";
-var recursionDetectionMiddleware = (options) => (next) => async (args) => {
-  const { request } = args;
-  if (!HttpRequest.isInstance(request) || options.runtime !== "node") {
-    return next(args);
-  }
-  const traceIdHeader = Object.keys(request.headers ?? {}).find((h) => h.toLowerCase() === TRACE_ID_HEADER_NAME.toLowerCase()) ?? TRACE_ID_HEADER_NAME;
-  if (request.headers.hasOwnProperty(traceIdHeader)) {
-    return next(args);
-  }
-  const functionName = process.env[ENV_LAMBDA_FUNCTION_NAME];
-  const traceId = process.env[ENV_TRACE_ID];
-  const nonEmptyString = (str) => typeof str === "string" && str.length > 0;
-  if (nonEmptyString(functionName) && nonEmptyString(traceId)) {
-    request.headers[TRACE_ID_HEADER_NAME] = traceId;
-  }
-  return next({
-    ...args,
-    request
-  });
-};
-var addRecursionDetectionMiddlewareOptions = {
-  step: "build",
-  tags: ["RECURSION_DETECTION"],
-  name: "recursionDetectionMiddleware",
-  override: true,
-  priority: "low"
-};
-var getRecursionDetectionPlugin = (options) => ({
-  applyToStack: (clientStack) => {
-    clientStack.add(recursionDetectionMiddleware(options), addRecursionDetectionMiddlewareOptions);
-  }
-});
-
-// node_modules/@smithy/smithy-client/dist-es/constants.js
-var SENSITIVE_STRING2 = "***SensitiveInformation***";
-
-// node_modules/@smithy/smithy-client/dist-es/exceptions.js
-var ServiceException = class _ServiceException extends Error {
-  $fault;
-  $response;
-  $retryable;
-  $metadata;
-  constructor(options) {
-    super(options.message);
-    Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
-    this.name = options.name;
-    this.$fault = options.$fault;
-    this.$metadata = options.$metadata;
-  }
-  static isInstance(value) {
-    if (!value)
-      return false;
-    const candidate = value;
-    return _ServiceException.prototype.isPrototypeOf(candidate) || Boolean(candidate.$fault) && Boolean(candidate.$metadata) && (candidate.$fault === "client" || candidate.$fault === "server");
-  }
-  static [Symbol.hasInstance](instance) {
-    if (!instance)
-      return false;
-    const candidate = instance;
-    if (this === _ServiceException) {
-      return _ServiceException.isInstance(instance);
-    }
-    if (_ServiceException.isInstance(instance)) {
-      if (candidate.name && this.name) {
-        return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
-      }
-      return this.prototype.isPrototypeOf(instance);
-    }
-    return false;
-  }
-};
-var decorateServiceException = (exception, additions = {}) => {
-  Object.entries(additions).filter(([, v]) => v !== void 0).forEach(([k, v]) => {
-    if (exception[k] == void 0 || exception[k] === "") {
-      exception[k] = v;
-    }
-  });
-  const message = exception.message || exception.Message || "UnknownError";
-  exception.message = message;
-  delete exception.Message;
-  return exception;
-};
-
-// node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/resolveAuthOptions.js
-var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
-  if (!authSchemePreference || authSchemePreference.length === 0) {
-    return candidateAuthOptions;
-  }
-  const preferredAuthOptions = [];
-  for (const preferredSchemeName of authSchemePreference) {
-    for (const candidateAuthOption of candidateAuthOptions) {
-      const candidateAuthSchemeName = candidateAuthOption.schemeId.split("#")[1];
-      if (candidateAuthSchemeName === preferredSchemeName) {
-        preferredAuthOptions.push(candidateAuthOption);
-      }
-    }
-  }
-  for (const candidateAuthOption of candidateAuthOptions) {
-    if (!preferredAuthOptions.find(({ schemeId }) => schemeId === candidateAuthOption.schemeId)) {
-      preferredAuthOptions.push(candidateAuthOption);
-    }
-  }
-  return preferredAuthOptions;
-};
-
-// node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js
-function convertHttpAuthSchemesToMap(httpAuthSchemes) {
-  const map = /* @__PURE__ */ new Map();
-  for (const scheme of httpAuthSchemes) {
-    map.set(scheme.schemeId, scheme);
-  }
-  return map;
-}
-var httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => {
-  const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input));
-  const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
-  const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
-  const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
-  const smithyContext = getSmithyContext(context);
-  const failureReasons = [];
-  for (const option of resolvedOptions) {
-    const scheme = authSchemes.get(option.schemeId);
-    if (!scheme) {
-      failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`);
-      continue;
-    }
-    const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config));
-    if (!identityProvider) {
-      failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`);
-      continue;
-    }
-    const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {};
-    option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties);
-    option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties);
-    smithyContext.selectedHttpAuthScheme = {
-      httpAuthOption: option,
-      identity: await identityProvider(option.identityProperties),
-      signer: scheme.signer
-    };
-    break;
-  }
-  if (!smithyContext.selectedHttpAuthScheme) {
-    throw new Error(failureReasons.join("\n"));
-  }
-  return next(args);
-};
-
-// node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.js
-var httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
-  step: "serialize",
-  tags: ["HTTP_AUTH_SCHEME"],
-  name: "httpAuthSchemeMiddleware",
-  override: true,
-  relation: "before",
-  toMiddleware: "endpointV2Middleware"
-};
-var getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
-  applyToStack: (clientStack) => {
-    clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
-      httpAuthSchemeParametersProvider,
-      identityProviderConfigProvider
-    }), httpAuthSchemeEndpointRuleSetMiddlewareOptions);
-  }
-});
-
-// node_modules/@smithy/middleware-serde/dist-es/deserializerMiddleware.js
-var deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
-  const { response } = await next(args);
-  try {
-    const parsed = await deserializer(response, options);
-    return {
-      response,
-      output: parsed
-    };
-  } catch (error) {
-    Object.defineProperty(error, "$response", {
-      value: response,
-      enumerable: false,
-      writable: false,
-      configurable: false
-    });
-    if (!("$metadata" in error)) {
-      const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
-      try {
-        error.message += "\n  " + hint;
-      } catch (e) {
-        if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
-          console.warn(hint);
-        } else {
-          context.logger?.warn?.(hint);
-        }
-      }
-      if (typeof error.$responseBodyText !== "undefined") {
-        if (error.$response) {
-          error.$response.body = error.$responseBodyText;
-        }
-      }
-      try {
-        if (HttpResponse.isInstance(response)) {
-          const { headers = {} } = response;
-          const headerEntries = Object.entries(headers);
-          error.$metadata = {
-            httpStatusCode: response.statusCode,
-            requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
-            extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
-            cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
-          };
-        }
-      } catch (e) {
-      }
-    }
-    throw error;
-  }
-};
-var findHeader = (pattern, headers) => {
-  return (headers.find(([k]) => {
-    return k.match(pattern);
-  }) || [void 0, void 0])[1];
-};
-
-// node_modules/@smithy/middleware-serde/dist-es/serializerMiddleware.js
-var serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
-  const endpointConfig = options;
-  const endpoint = context.endpointV2?.url && endpointConfig.urlParser ? async () => endpointConfig.urlParser(context.endpointV2.url) : endpointConfig.endpoint;
-  if (!endpoint) {
-    throw new Error("No valid endpoint provider available.");
-  }
-  const request = await serializer(args.input, { ...options, endpoint });
-  return next({
-    ...args,
-    request
-  });
-};
-
-// node_modules/@smithy/middleware-serde/dist-es/serdePlugin.js
-var deserializerMiddlewareOption = {
-  name: "deserializerMiddleware",
-  step: "deserialize",
-  tags: ["DESERIALIZER"],
-  override: true
-};
-var serializerMiddlewareOption = {
-  name: "serializerMiddleware",
-  step: "serialize",
-  tags: ["SERIALIZER"],
-  override: true
-};
-function getSerdePlugin(config, serializer, deserializer) {
-  return {
-    applyToStack: (commandStack) => {
-      commandStack.add(deserializerMiddleware(config, deserializer), deserializerMiddlewareOption);
-      commandStack.add(serializerMiddleware(config, serializer), serializerMiddlewareOption);
-    }
-  };
-}
-
-// node_modules/@smithy/core/dist-es/middleware-http-signing/httpSigningMiddleware.js
-var defaultErrorHandler = (signingProperties) => (error) => {
-  throw error;
-};
-var defaultSuccessHandler = (httpResponse, signingProperties) => {
-};
-var httpSigningMiddleware = (config) => (next, context) => async (args) => {
-  if (!HttpRequest.isInstance(args.request)) {
-    return next(args);
-  }
-  const smithyContext = getSmithyContext(context);
-  const scheme = smithyContext.selectedHttpAuthScheme;
-  if (!scheme) {
-    throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
-  }
-  const { httpAuthOption: { signingProperties = {} }, identity, signer } = scheme;
-  const output = await next({
-    ...args,
-    request: await signer.sign(args.request, identity, signingProperties)
-  }).catch((signer.errorHandler || defaultErrorHandler)(signingProperties));
-  (signer.successHandler || defaultSuccessHandler)(output.response, signingProperties);
-  return output;
-};
-
-// node_modules/@smithy/core/dist-es/middleware-http-signing/getHttpSigningMiddleware.js
-var httpSigningMiddlewareOptions = {
-  step: "finalizeRequest",
-  tags: ["HTTP_SIGNING"],
-  name: "httpSigningMiddleware",
-  aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"],
-  override: true,
-  relation: "after",
-  toMiddleware: "retryMiddleware"
-};
-var getHttpSigningPlugin = (config) => ({
-  applyToStack: (clientStack) => {
-    clientStack.addRelativeTo(httpSigningMiddleware(config), httpSigningMiddlewareOptions);
-  }
-});
-
-// node_modules/@smithy/core/dist-es/util-identity-and-auth/DefaultIdentityProviderConfig.js
-var DefaultIdentityProviderConfig = class {
-  authSchemes = /* @__PURE__ */ new Map();
-  constructor(config) {
-    for (const [key, value] of Object.entries(config)) {
-      if (value !== void 0) {
-        this.authSchemes.set(key, value);
-      }
-    }
-  }
-  getIdentityProvider(schemeId) {
-    return this.authSchemes.get(schemeId);
-  }
-};
-
-// node_modules/@smithy/core/dist-es/normalizeProvider.js
-var normalizeProvider2 = (input) => {
-  if (typeof input === "function")
-    return input;
-  const promisified = Promise.resolve(input);
-  return () => promisified;
-};
-
-// node_modules/@smithy/util-utf8/dist-es/toUint8Array.js
-var toUint8Array = (data) => {
-  if (typeof data === "string") {
-    return fromUtf8(data);
-  }
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
-  }
-  return new Uint8Array(data);
-};
-
-// node_modules/@smithy/util-stream/dist-es/blob/Uint8ArrayBlobAdapter.js
-var Uint8ArrayBlobAdapter = class _Uint8ArrayBlobAdapter extends Uint8Array {
-  static fromString(source, encoding = "utf-8") {
-    if (typeof source === "string") {
-      if (encoding === "base64") {
-        return _Uint8ArrayBlobAdapter.mutate(fromBase64(source));
-      }
-      return _Uint8ArrayBlobAdapter.mutate(fromUtf8(source));
-    }
-    throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
-  }
-  static mutate(source) {
-    Object.setPrototypeOf(source, _Uint8ArrayBlobAdapter.prototype);
-    return source;
-  }
-  transformToString(encoding = "utf-8") {
-    if (encoding === "base64") {
-      return toBase64(this);
-    }
-    return toUtf8(this);
-  }
-};
-
-// node_modules/@smithy/core/dist-es/submodules/protocols/collect-stream-body.js
-var collectBody = async (streamBody = new Uint8Array(), context) => {
-  if (streamBody instanceof Uint8Array) {
-    return Uint8ArrayBlobAdapter.mutate(streamBody);
-  }
-  if (!streamBody) {
-    return Uint8ArrayBlobAdapter.mutate(new Uint8Array());
-  }
-  const fromContext = context.streamCollector(streamBody);
-  return Uint8ArrayBlobAdapter.mutate(await fromContext);
-};
-
-// node_modules/@smithy/core/dist-es/submodules/protocols/extended-encode-uri-component.js
-function extendedEncodeURIComponent(str) {
-  return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
-    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
-  });
-}
-
-// node_modules/@smithy/uuid/dist-es/randomUUID.js
-import crypto2 from "crypto";
-var randomUUID = crypto2.randomUUID.bind(crypto2);
-
-// node_modules/@smithy/uuid/dist-es/v4.js
-var decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-var v4 = () => {
-  if (randomUUID) {
-    return randomUUID();
-  }
-  const rnds = new Uint8Array(16);
-  crypto.getRandomValues(rnds);
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  return decimalToHex[rnds[0]] + decimalToHex[rnds[1]] + decimalToHex[rnds[2]] + decimalToHex[rnds[3]] + "-" + decimalToHex[rnds[4]] + decimalToHex[rnds[5]] + "-" + decimalToHex[rnds[6]] + decimalToHex[rnds[7]] + "-" + decimalToHex[rnds[8]] + decimalToHex[rnds[9]] + "-" + decimalToHex[rnds[10]] + decimalToHex[rnds[11]] + decimalToHex[rnds[12]] + decimalToHex[rnds[13]] + decimalToHex[rnds[14]] + decimalToHex[rnds[15]];
-};
-
-// node_modules/@smithy/core/dist-es/setFeature.js
-function setFeature(context, feature, value) {
-  if (!context.__smithy_context) {
-    context.__smithy_context = {
-      features: {}
-    };
-  } else if (!context.__smithy_context.features) {
-    context.__smithy_context.features = {};
-  }
-  context.__smithy_context.features[feature] = value;
-}
-
-// node_modules/@smithy/core/dist-es/util-identity-and-auth/memoizeIdentityProvider.js
-var createIsIdentityExpiredFunction = (expirationMs) => function isIdentityExpired2(identity) {
-  return doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
-};
-var EXPIRATION_MS = 3e5;
-var isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
-var doesIdentityRequireRefresh = (identity) => identity.expiration !== void 0;
-var memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
-  if (provider === void 0) {
-    return void 0;
-  }
-  const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider;
-  let resolved;
-  let pending;
-  let hasResult;
-  let isConstant = false;
-  const coalesceProvider = async (options) => {
-    if (!pending) {
-      pending = normalizedProvider(options);
-    }
-    try {
-      resolved = await pending;
-      hasResult = true;
-      isConstant = false;
-    } finally {
-      pending = void 0;
-    }
-    return resolved;
-  };
-  if (isExpired === void 0) {
-    return async (options) => {
-      if (!hasResult || options?.forceRefresh) {
-        resolved = await coalesceProvider(options);
-      }
-      return resolved;
-    };
-  }
-  return async (options) => {
-    if (!hasResult || options?.forceRefresh) {
-      resolved = await coalesceProvider(options);
-    }
-    if (isConstant) {
-      return resolved;
-    }
-    if (!requiresRefresh(resolved)) {
-      isConstant = true;
-      return resolved;
-    }
-    if (isExpired(resolved)) {
-      await coalesceProvider(options);
-      return resolved;
-    }
-    return resolved;
-  };
-};
-
-// node_modules/@aws-sdk/middleware-user-agent/dist-es/configurations.js
-var DEFAULT_UA_APP_ID = void 0;
-function isValidUserAgentAppId(appId) {
-  if (appId === void 0) {
-    return true;
-  }
-  return typeof appId === "string" && appId.length <= 50;
-}
-function resolveUserAgentConfig(input) {
-  const normalizedAppIdProvider = normalizeProvider2(input.userAgentAppId ?? DEFAULT_UA_APP_ID);
-  const { customUserAgent } = input;
-  return Object.assign(input, {
-    customUserAgent: typeof customUserAgent === "string" ? [[customUserAgent]] : customUserAgent,
-    userAgentAppId: async () => {
-      const appId = await normalizedAppIdProvider();
-      if (!isValidUserAgentAppId(appId)) {
-        const logger = input.logger?.constructor?.name === "NoOpLogger" || !input.logger ? console : input.logger;
-        if (typeof appId !== "string") {
-          logger?.warn("userAgentAppId must be a string or undefined.");
-        } else if (appId.length > 50) {
-          logger?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.");
-        }
-      }
-      return appId;
-    }
-  });
-}
-
-// node_modules/@smithy/util-endpoints/dist-es/cache/EndpointCache.js
-var EndpointCache = class {
-  capacity;
-  data = /* @__PURE__ */ new Map();
-  parameters = [];
-  constructor({ size, params }) {
-    this.capacity = size ?? 50;
-    if (params) {
-      this.parameters = params;
-    }
-  }
-  get(endpointParams, resolver) {
-    const key = this.hash(endpointParams);
-    if (key === false) {
-      return resolver();
-    }
-    if (!this.data.has(key)) {
-      if (this.data.size > this.capacity + 10) {
-        const keys = this.data.keys();
-        let i = 0;
-        while (true) {
-          const { value, done } = keys.next();
-          this.data.delete(value);
-          if (done || ++i > 10) {
-            break;
-          }
-        }
-      }
-      this.data.set(key, resolver());
-    }
-    return this.data.get(key);
-  }
-  size() {
-    return this.data.size;
-  }
-  hash(endpointParams) {
-    let buffer = "";
-    const { parameters } = this;
-    if (parameters.length === 0) {
-      return false;
-    }
-    for (const param of parameters) {
-      const val = String(endpointParams[param] ?? "");
-      if (val.includes("|;")) {
-        return false;
-      }
-      buffer += val + "|;";
-    }
-    return buffer;
-  }
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/isIpAddress.js
-var IP_V4_REGEX = new RegExp(`^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$`);
-var isIpAddress = (value) => IP_V4_REGEX.test(value) || value.startsWith("[") && value.endsWith("]");
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/isValidHostLabel.js
-var VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
-var isValidHostLabel = (value, allowSubDomains = false) => {
-  if (!allowSubDomains) {
-    return VALID_HOST_LABEL_REGEX.test(value);
-  }
-  const labels = value.split(".");
-  for (const label of labels) {
-    if (!isValidHostLabel(label)) {
-      return false;
-    }
-  }
-  return true;
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/customEndpointFunctions.js
-var customEndpointFunctions = {};
-
-// node_modules/@smithy/util-endpoints/dist-es/debug/debugId.js
-var debugId = "endpoints";
-
-// node_modules/@smithy/util-endpoints/dist-es/debug/toDebugString.js
-function toDebugString(input) {
-  if (typeof input !== "object" || input == null) {
-    return input;
-  }
-  if ("ref" in input) {
-    return `$${toDebugString(input.ref)}`;
-  }
-  if ("fn" in input) {
-    return `${input.fn}(${(input.argv || []).map(toDebugString).join(", ")})`;
-  }
-  return JSON.stringify(input, null, 2);
-}
-
-// node_modules/@smithy/util-endpoints/dist-es/types/EndpointError.js
-var EndpointError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "EndpointError";
-  }
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/booleanEquals.js
-var booleanEquals = (value1, value2) => value1 === value2;
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/getAttrPathList.js
-var getAttrPathList = (path) => {
-  const parts = path.split(".");
-  const pathList = [];
-  for (const part of parts) {
-    const squareBracketIndex = part.indexOf("[");
-    if (squareBracketIndex !== -1) {
-      if (part.indexOf("]") !== part.length - 1) {
-        throw new EndpointError(`Path: '${path}' does not end with ']'`);
-      }
-      const arrayIndex = part.slice(squareBracketIndex + 1, -1);
-      if (Number.isNaN(parseInt(arrayIndex))) {
-        throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path}'`);
-      }
-      if (squareBracketIndex !== 0) {
-        pathList.push(part.slice(0, squareBracketIndex));
-      }
-      pathList.push(arrayIndex);
-    } else {
-      pathList.push(part);
-    }
-  }
-  return pathList;
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/getAttr.js
-var getAttr = (value, path) => getAttrPathList(path).reduce((acc, index) => {
-  if (typeof acc !== "object") {
-    throw new EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`);
-  } else if (Array.isArray(acc)) {
-    return acc[parseInt(index)];
-  }
-  return acc[index];
-}, value);
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/isSet.js
-var isSet = (value) => value != null;
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/not.js
-var not = (value) => !value;
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/parseURL.js
-var DEFAULT_PORTS = {
-  [EndpointURLScheme.HTTP]: 80,
-  [EndpointURLScheme.HTTPS]: 443
-};
-var parseURL = (value) => {
-  const whatwgURL = (() => {
-    try {
-      if (value instanceof URL) {
-        return value;
-      }
-      if (typeof value === "object" && "hostname" in value) {
-        const { hostname: hostname2, port, protocol: protocol2 = "", path = "", query = {} } = value;
-        const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path}`);
-        url.search = Object.entries(query).map(([k, v]) => `${k}=${v}`).join("&");
-        return url;
-      }
-      return new URL(value);
-    } catch (error) {
-      return null;
-    }
-  })();
-  if (!whatwgURL) {
-    console.error(`Unable to parse ${JSON.stringify(value)} as a whatwg URL.`);
-    return null;
-  }
-  const urlString = whatwgURL.href;
-  const { host, hostname, pathname, protocol, search } = whatwgURL;
-  if (search) {
-    return null;
-  }
-  const scheme = protocol.slice(0, -1);
-  if (!Object.values(EndpointURLScheme).includes(scheme)) {
-    return null;
-  }
-  const isIp = isIpAddress(hostname);
-  const inputContainsDefaultPort = urlString.includes(`${host}:${DEFAULT_PORTS[scheme]}`) || typeof value === "string" && value.includes(`${host}:${DEFAULT_PORTS[scheme]}`);
-  const authority = `${host}${inputContainsDefaultPort ? `:${DEFAULT_PORTS[scheme]}` : ``}`;
-  return {
-    scheme,
-    authority,
-    path: pathname,
-    normalizedPath: pathname.endsWith("/") ? pathname : `${pathname}/`,
-    isIp
-  };
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/stringEquals.js
-var stringEquals = (value1, value2) => value1 === value2;
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/substring.js
-var substring = (input, start, stop, reverse) => {
-  if (start >= stop || input.length < stop) {
-    return null;
-  }
-  if (!reverse) {
-    return input.substring(start, stop);
-  }
-  return input.substring(input.length - stop, input.length - start);
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/lib/uriEncode.js
-var uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/endpointFunctions.js
-var endpointFunctions = {
-  booleanEquals,
-  getAttr,
-  isSet,
-  isValidHostLabel,
-  not,
-  parseURL,
-  stringEquals,
-  substring,
-  uriEncode
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTemplate.js
-var evaluateTemplate = (template, options) => {
-  const evaluatedTemplateArr = [];
-  const templateContext = {
-    ...options.endpointParams,
-    ...options.referenceRecord
-  };
-  let currentIndex = 0;
-  while (currentIndex < template.length) {
-    const openingBraceIndex = template.indexOf("{", currentIndex);
-    if (openingBraceIndex === -1) {
-      evaluatedTemplateArr.push(template.slice(currentIndex));
-      break;
-    }
-    evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex));
-    const closingBraceIndex = template.indexOf("}", openingBraceIndex);
-    if (closingBraceIndex === -1) {
-      evaluatedTemplateArr.push(template.slice(openingBraceIndex));
-      break;
-    }
-    if (template[openingBraceIndex + 1] === "{" && template[closingBraceIndex + 1] === "}") {
-      evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex));
-      currentIndex = closingBraceIndex + 2;
-    }
-    const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex);
-    if (parameterName.includes("#")) {
-      const [refName, attrName] = parameterName.split("#");
-      evaluatedTemplateArr.push(getAttr(templateContext[refName], attrName));
-    } else {
-      evaluatedTemplateArr.push(templateContext[parameterName]);
-    }
-    currentIndex = closingBraceIndex + 1;
-  }
-  return evaluatedTemplateArr.join("");
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/getReferenceValue.js
-var getReferenceValue = ({ ref }, options) => {
-  const referenceRecord = {
-    ...options.endpointParams,
-    ...options.referenceRecord
-  };
-  return referenceRecord[ref];
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/evaluateExpression.js
-var evaluateExpression = (obj, keyName, options) => {
-  if (typeof obj === "string") {
-    return evaluateTemplate(obj, options);
-  } else if (obj["fn"]) {
-    return group.callFunction(obj, options);
-  } else if (obj["ref"]) {
-    return getReferenceValue(obj, options);
-  }
-  throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
-};
-var callFunction = ({ fn, argv }, options) => {
-  const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : group.evaluateExpression(arg, "arg", options));
-  const fnSegments = fn.split(".");
-  if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {
-    return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);
-  }
-  return endpointFunctions[fn](...evaluatedArgs);
-};
-var group = {
-  evaluateExpression,
-  callFunction
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/evaluateCondition.js
-var evaluateCondition = ({ assign, ...fnArgs }, options) => {
-  if (assign && assign in options.referenceRecord) {
-    throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
-  }
-  const value = callFunction(fnArgs, options);
-  options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(fnArgs)} = ${toDebugString(value)}`);
-  return {
-    result: value === "" ? true : !!value,
-    ...assign != null && { toAssign: { name: assign, value } }
-  };
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/evaluateConditions.js
-var evaluateConditions = (conditions = [], options) => {
-  const conditionsReferenceRecord = {};
-  for (const condition of conditions) {
-    const { result, toAssign } = evaluateCondition(condition, {
-      ...options,
-      referenceRecord: {
-        ...options.referenceRecord,
-        ...conditionsReferenceRecord
-      }
-    });
-    if (!result) {
-      return { result };
-    }
-    if (toAssign) {
-      conditionsReferenceRecord[toAssign.name] = toAssign.value;
-      options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
-    }
-  }
-  return { result: true, referenceRecord: conditionsReferenceRecord };
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointHeaders.js
-var getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((acc, [headerKey, headerVal]) => ({
-  ...acc,
-  [headerKey]: headerVal.map((headerValEntry) => {
-    const processedExpr = evaluateExpression(headerValEntry, "Header value entry", options);
-    if (typeof processedExpr !== "string") {
-      throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);
-    }
-    return processedExpr;
-  })
-}), {});
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js
-var getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
-  ...acc,
-  [propertyKey]: group2.getEndpointProperty(propertyVal, options)
-}), {});
-var getEndpointProperty = (property, options) => {
-  if (Array.isArray(property)) {
-    return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
-  }
-  switch (typeof property) {
-    case "string":
-      return evaluateTemplate(property, options);
-    case "object":
-      if (property === null) {
-        throw new EndpointError(`Unexpected endpoint property: ${property}`);
-      }
-      return group2.getEndpointProperties(property, options);
-    case "boolean":
-      return property;
-    default:
-      throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
-  }
-};
-var group2 = {
-  getEndpointProperty,
-  getEndpointProperties
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointUrl.js
-var getEndpointUrl = (endpointUrl, options) => {
-  const expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
-  if (typeof expression === "string") {
-    try {
-      return new URL(expression);
-    } catch (error) {
-      console.error(`Failed to construct URL with ${expression}`, error);
-      throw error;
-    }
-  }
-  throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/evaluateEndpointRule.js
-var evaluateEndpointRule = (endpointRule, options) => {
-  const { conditions, endpoint } = endpointRule;
-  const { result, referenceRecord } = evaluateConditions(conditions, options);
-  if (!result) {
-    return;
-  }
-  const endpointRuleOptions = {
-    ...options,
-    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
-  };
-  const { url, properties, headers } = endpoint;
-  options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`);
-  return {
-    ...headers != void 0 && {
-      headers: getEndpointHeaders(headers, endpointRuleOptions)
-    },
-    ...properties != void 0 && {
-      properties: getEndpointProperties(properties, endpointRuleOptions)
-    },
-    url: getEndpointUrl(url, endpointRuleOptions)
-  };
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/evaluateErrorRule.js
-var evaluateErrorRule = (errorRule, options) => {
-  const { conditions, error } = errorRule;
-  const { result, referenceRecord } = evaluateConditions(conditions, options);
-  if (!result) {
-    return;
-  }
-  throw new EndpointError(evaluateExpression(error, "Error", {
-    ...options,
-    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
-  }));
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js
-var evaluateRules = (rules, options) => {
-  for (const rule of rules) {
-    if (rule.type === "endpoint") {
-      const endpointOrUndefined = evaluateEndpointRule(rule, options);
-      if (endpointOrUndefined) {
-        return endpointOrUndefined;
-      }
-    } else if (rule.type === "error") {
-      evaluateErrorRule(rule, options);
-    } else if (rule.type === "tree") {
-      const endpointOrUndefined = group3.evaluateTreeRule(rule, options);
-      if (endpointOrUndefined) {
-        return endpointOrUndefined;
-      }
-    } else {
-      throw new EndpointError(`Unknown endpoint rule: ${rule}`);
-    }
-  }
-  throw new EndpointError(`Rules evaluation failed`);
-};
-var evaluateTreeRule = (treeRule, options) => {
-  const { conditions, rules } = treeRule;
-  const { result, referenceRecord } = evaluateConditions(conditions, options);
-  if (!result) {
-    return;
-  }
-  return group3.evaluateRules(rules, {
-    ...options,
-    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
-  });
-};
-var group3 = {
-  evaluateRules,
-  evaluateTreeRule
-};
-
-// node_modules/@smithy/util-endpoints/dist-es/resolveEndpoint.js
-var resolveEndpoint = (ruleSetObject, options) => {
-  const { endpointParams, logger } = options;
-  const { parameters, rules } = ruleSetObject;
-  options.logger?.debug?.(`${debugId} Initial EndpointParams: ${toDebugString(endpointParams)}`);
-  const paramsWithDefault = Object.entries(parameters).filter(([, v]) => v.default != null).map(([k, v]) => [k, v.default]);
-  if (paramsWithDefault.length > 0) {
-    for (const [paramKey, paramDefaultValue] of paramsWithDefault) {
-      endpointParams[paramKey] = endpointParams[paramKey] ?? paramDefaultValue;
-    }
-  }
-  const requiredParams = Object.entries(parameters).filter(([, v]) => v.required).map(([k]) => k);
-  for (const requiredParam of requiredParams) {
-    if (endpointParams[requiredParam] == null) {
-      throw new EndpointError(`Missing required parameter: '${requiredParam}'`);
-    }
-  }
-  const endpoint = evaluateRules(rules, { endpointParams, logger, referenceRecord: {} });
-  options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
-  return endpoint;
-};
-
-// node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/isVirtualHostableS3Bucket.js
-var isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
-  if (allowSubDomains) {
-    for (const label of value.split(".")) {
-      if (!isVirtualHostableS3Bucket(label)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (!isValidHostLabel(value)) {
-    return false;
-  }
-  if (value.length < 3 || value.length > 63) {
-    return false;
-  }
-  if (value !== value.toLowerCase()) {
-    return false;
-  }
-  if (isIpAddress(value)) {
-    return false;
-  }
-  return true;
-};
-
-// node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/parseArn.js
-var ARN_DELIMITER = ":";
-var RESOURCE_DELIMITER = "/";
-var parseArn = (value) => {
-  const segments = value.split(ARN_DELIMITER);
-  if (segments.length < 6)
-    return null;
-  const [arn, partition2, service, region, accountId, ...resourcePath] = segments;
-  if (arn !== "arn" || partition2 === "" || service === "" || resourcePath.join(ARN_DELIMITER) === "")
-    return null;
-  const resourceId = resourcePath.map((resource) => resource.split(RESOURCE_DELIMITER)).flat();
-  return {
-    partition: partition2,
-    service,
-    region,
-    accountId,
-    resourceId
-  };
-};
-
-// node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partitions.json
-var partitions_default = {
-  partitions: [{
-    id: "aws",
-    outputs: {
-      dnsSuffix: "amazonaws.com",
-      dualStackDnsSuffix: "api.aws",
-      implicitGlobalRegion: "us-east-1",
-      name: "aws",
-      supportsDualStack: true,
-      supportsFIPS: true
-    },
-    regionRegex: "^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$",
-    regions: {
-      "af-south-1": {
-        description: "Africa (Cape Town)"
-      },
-      "ap-east-1": {
-        description: "Asia Pacific (Hong Kong)"
-      },
-      "ap-east-2": {
-        description: "Asia Pacific (Taipei)"
-      },
-      "ap-northeast-1": {
-        description: "Asia Pacific (Tokyo)"
-      },
-      "ap-northeast-2": {
-        description: "Asia Pacific (Seoul)"
-      },
-      "ap-northeast-3": {
-        description: "Asia Pacific (Osaka)"
-      },
-      "ap-south-1": {
-        description: "Asia Pacific (Mumbai)"
-      },
-      "ap-south-2": {
-        description: "Asia Pacific (Hyderabad)"
-      },
-      "ap-southeast-1": {
-        description: "Asia Pacific (Singapore)"
-      },
-      "ap-southeast-2": {
-        description: "Asia Pacific (Sydney)"
-      },
-      "ap-southeast-3": {
-        description: "Asia Pacific (Jakarta)"
-      },
-      "ap-southeast-4": {
-        description: "Asia Pacific (Melbourne)"
-      },
-      "ap-southeast-5": {
-        description: "Asia Pacific (Malaysia)"
-      },
-      "ap-southeast-7": {
-        description: "Asia Pacific (Thailand)"
-      },
-      "aws-global": {
-        description: "AWS Standard global region"
-      },
-      "ca-central-1": {
-        description: "Canada (Central)"
-      },
-      "ca-west-1": {
-        description: "Canada West (Calgary)"
-      },
-      "eu-central-1": {
-        description: "Europe (Frankfurt)"
-      },
-      "eu-central-2": {
-        description: "Europe (Zurich)"
-      },
-      "eu-north-1": {
-        description: "Europe (Stockholm)"
-      },
-      "eu-south-1": {
-        description: "Europe (Milan)"
-      },
-      "eu-south-2": {
-        description: "Europe (Spain)"
-      },
-      "eu-west-1": {
-        description: "Europe (Ireland)"
-      },
-      "eu-west-2": {
-        description: "Europe (London)"
-      },
-      "eu-west-3": {
-        description: "Europe (Paris)"
-      },
-      "il-central-1": {
-        description: "Israel (Tel Aviv)"
-      },
-      "me-central-1": {
-        description: "Middle East (UAE)"
-      },
-      "me-south-1": {
-        description: "Middle East (Bahrain)"
-      },
-      "mx-central-1": {
-        description: "Mexico (Central)"
-      },
-      "sa-east-1": {
-        description: "South America (Sao Paulo)"
-      },
-      "us-east-1": {
-        description: "US East (N. Virginia)"
-      },
-      "us-east-2": {
-        description: "US East (Ohio)"
-      },
-      "us-west-1": {
-        description: "US West (N. California)"
-      },
-      "us-west-2": {
-        description: "US West (Oregon)"
-      }
-    }
-  }, {
-    id: "aws-cn",
-    outputs: {
-      dnsSuffix: "amazonaws.com.cn",
-      dualStackDnsSuffix: "api.amazonwebservices.com.cn",
-      implicitGlobalRegion: "cn-northwest-1",
-      name: "aws-cn",
-      supportsDualStack: true,
-      supportsFIPS: true
-    },
-    regionRegex: "^cn\\-\\w+\\-\\d+$",
-    regions: {
-      "aws-cn-global": {
-        description: "AWS China global region"
-      },
-      "cn-north-1": {
-        description: "China (Beijing)"
-      },
-      "cn-northwest-1": {
-        description: "China (Ningxia)"
-      }
-    }
-  }, {
-    id: "aws-us-gov",
-    outputs: {
-      dnsSuffix: "amazonaws.com",
-      dualStackDnsSuffix: "api.aws",
-      implicitGlobalRegion: "us-gov-west-1",
-      name: "aws-us-gov",
-      supportsDualStack: true,
-      supportsFIPS: true
-    },
-    regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
-    regions: {
-      "aws-us-gov-global": {
-        description: "AWS GovCloud (US) global region"
-      },
-      "us-gov-east-1": {
-        description: "AWS GovCloud (US-East)"
-      },
-      "us-gov-west-1": {
-        description: "AWS GovCloud (US-West)"
-      }
-    }
-  }, {
-    id: "aws-iso",
-    outputs: {
-      dnsSuffix: "c2s.ic.gov",
-      dualStackDnsSuffix: "c2s.ic.gov",
-      implicitGlobalRegion: "us-iso-east-1",
-      name: "aws-iso",
-      supportsDualStack: false,
-      supportsFIPS: true
-    },
-    regionRegex: "^us\\-iso\\-\\w+\\-\\d+$",
-    regions: {
-      "aws-iso-global": {
-        description: "AWS ISO (US) global region"
-      },
-      "us-iso-east-1": {
-        description: "US ISO East"
-      },
-      "us-iso-west-1": {
-        description: "US ISO WEST"
-      }
-    }
-  }, {
-    id: "aws-iso-b",
-    outputs: {
-      dnsSuffix: "sc2s.sgov.gov",
-      dualStackDnsSuffix: "sc2s.sgov.gov",
-      implicitGlobalRegion: "us-isob-east-1",
-      name: "aws-iso-b",
-      supportsDualStack: false,
-      supportsFIPS: true
-    },
-    regionRegex: "^us\\-isob\\-\\w+\\-\\d+$",
-    regions: {
-      "aws-iso-b-global": {
-        description: "AWS ISOB (US) global region"
-      },
-      "us-isob-east-1": {
-        description: "US ISOB East (Ohio)"
-      }
-    }
-  }, {
-    id: "aws-iso-e",
-    outputs: {
-      dnsSuffix: "cloud.adc-e.uk",
-      dualStackDnsSuffix: "cloud.adc-e.uk",
-      implicitGlobalRegion: "eu-isoe-west-1",
-      name: "aws-iso-e",
-      supportsDualStack: false,
-      supportsFIPS: true
-    },
-    regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$",
-    regions: {
-      "aws-iso-e-global": {
-        description: "AWS ISOE (Europe) global region"
-      },
-      "eu-isoe-west-1": {
-        description: "EU ISOE West"
-      }
-    }
-  }, {
-    id: "aws-iso-f",
-    outputs: {
-      dnsSuffix: "csp.hci.ic.gov",
-      dualStackDnsSuffix: "csp.hci.ic.gov",
-      implicitGlobalRegion: "us-isof-south-1",
-      name: "aws-iso-f",
-      supportsDualStack: false,
-      supportsFIPS: true
-    },
-    regionRegex: "^us\\-isof\\-\\w+\\-\\d+$",
-    regions: {
-      "aws-iso-f-global": {
-        description: "AWS ISOF global region"
-      },
-      "us-isof-east-1": {
-        description: "US ISOF EAST"
-      },
-      "us-isof-south-1": {
-        description: "US ISOF SOUTH"
-      }
-    }
-  }, {
-    id: "aws-eusc",
-    outputs: {
-      dnsSuffix: "amazonaws.eu",
-      dualStackDnsSuffix: "amazonaws.eu",
-      implicitGlobalRegion: "eusc-de-east-1",
-      name: "aws-eusc",
-      supportsDualStack: false,
-      supportsFIPS: true
-    },
-    regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$",
-    regions: {
-      "eusc-de-east-1": {
-        description: "EU (Germany)"
-      }
-    }
-  }],
-  version: "1.1"
-};
-
-// node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partition.js
-var selectedPartitionsInfo = partitions_default;
-var selectedUserAgentPrefix = "";
-var partition = (value) => {
-  const { partitions } = selectedPartitionsInfo;
-  for (const partition2 of partitions) {
-    const { regions, outputs } = partition2;
-    for (const [region, regionData] of Object.entries(regions)) {
-      if (region === value) {
-        return {
-          ...outputs,
-          ...regionData
-        };
-      }
-    }
-  }
-  for (const partition2 of partitions) {
-    const { regionRegex, outputs } = partition2;
-    if (new RegExp(regionRegex).test(value)) {
-      return {
-        ...outputs
-      };
-    }
-  }
-  const DEFAULT_PARTITION = partitions.find((partition2) => partition2.id === "aws");
-  if (!DEFAULT_PARTITION) {
-    throw new Error("Provided region was not found in the partition array or regex, and default partition with id 'aws' doesn't exist.");
-  }
-  return {
-    ...DEFAULT_PARTITION.outputs
-  };
-};
-var getUserAgentPrefix = () => selectedUserAgentPrefix;
-
-// node_modules/@aws-sdk/util-endpoints/dist-es/aws.js
-var awsEndpointFunctions = {
-  isVirtualHostableS3Bucket,
-  parseArn,
-  partition
-};
-customEndpointFunctions.aws = awsEndpointFunctions;
-
-// node_modules/@aws-sdk/core/dist-es/submodules/client/emitWarningIfUnsupportedVersion.js
-var state = {
-  warningEmitted: false
-};
-var emitWarningIfUnsupportedVersion = (version) => {
-  if (version && !state.warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 18) {
-    state.warningEmitted = true;
-    process.emitWarning(`NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will
-no longer support Node.js 16.x on January 6, 2025.
-
-To continue receiving updates to AWS services, bug fixes, and security
-updates please upgrade to a supported Node.js LTS version.
-
-More information can be found at: https://a.co/74kJMmI`);
-  }
-};
-
-// node_modules/@aws-sdk/core/dist-es/submodules/client/setFeature.js
-function setFeature2(context, feature, value) {
-  if (!context.__aws_sdk_context) {
-    context.__aws_sdk_context = {
-      features: {}
-    };
-  } else if (!context.__aws_sdk_context.features) {
-    context.__aws_sdk_context.features = {};
-  }
-  context.__aws_sdk_context.features[feature] = value;
-}
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getDateHeader.js
-var getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : void 0;
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getSkewCorrectedDate.js
-var getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/isClockSkewed.js
-var isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 3e5;
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getUpdatedSystemClockOffset.js
-var getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
-  const clockTimeInMs = Date.parse(clockTime);
-  if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
-    return clockTimeInMs - Date.now();
-  }
-  return currentSystemClockOffset;
-};
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.js
-var throwSigningPropertyError = (name, property) => {
-  if (!property) {
-    throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`);
-  }
-  return property;
-};
-var validateSigningProperties = async (signingProperties) => {
-  const context = throwSigningPropertyError("context", signingProperties.context);
-  const config = throwSigningPropertyError("config", signingProperties.config);
-  const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
-  const signerFunction = throwSigningPropertyError("signer", config.signer);
-  const signer = await signerFunction(authScheme);
-  const signingRegion = signingProperties?.signingRegion;
-  const signingRegionSet = signingProperties?.signingRegionSet;
-  const signingName = signingProperties?.signingName;
-  return {
-    config,
-    signer,
-    signingRegion,
-    signingRegionSet,
-    signingName
-  };
-};
-var AwsSdkSigV4Signer = class {
-  async sign(httpRequest, identity, signingProperties) {
-    if (!HttpRequest.isInstance(httpRequest)) {
-      throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
-    }
-    const validatedProps = await validateSigningProperties(signingProperties);
-    const { config, signer } = validatedProps;
-    let { signingRegion, signingName } = validatedProps;
-    const handlerExecutionContext = signingProperties.context;
-    if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) {
-      const [first, second] = handlerExecutionContext.authSchemes;
-      if (first?.name === "sigv4a" && second?.name === "sigv4") {
-        signingRegion = second?.signingRegion ?? signingRegion;
-        signingName = second?.signingName ?? signingName;
-      }
-    }
-    const signedRequest = await signer.sign(httpRequest, {
-      signingDate: getSkewCorrectedDate(config.systemClockOffset),
-      signingRegion,
-      signingService: signingName
-    });
-    return signedRequest;
-  }
-  errorHandler(signingProperties) {
-    return (error) => {
-      const serverTime = error.ServerTime ?? getDateHeader(error.$response);
-      if (serverTime) {
-        const config = throwSigningPropertyError("config", signingProperties.config);
-        const initialSystemClockOffset = config.systemClockOffset;
-        config.systemClockOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset);
-        const clockSkewCorrected = config.systemClockOffset !== initialSystemClockOffset;
-        if (clockSkewCorrected && error.$metadata) {
-          error.$metadata.clockSkewCorrected = true;
-        }
-      }
-      throw error;
-    };
-  }
-  successHandler(httpResponse, signingProperties) {
-    const dateHeader = getDateHeader(httpResponse);
-    if (dateHeader) {
-      const config = throwSigningPropertyError("config", signingProperties.config);
-      config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset);
-    }
-  }
-};
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4ASigner.js
-var AwsSdkSigV4ASigner = class extends AwsSdkSigV4Signer {
-  async sign(httpRequest, identity, signingProperties) {
-    if (!HttpRequest.isInstance(httpRequest)) {
-      throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
-    }
-    const { config, signer, signingRegion, signingRegionSet, signingName } = await validateSigningProperties(signingProperties);
-    const configResolvedSigningRegionSet = await config.sigv4aSigningRegionSet?.();
-    const multiRegionOverride = (configResolvedSigningRegionSet ?? signingRegionSet ?? [signingRegion]).join(",");
-    const signedRequest = await signer.sign(httpRequest, {
-      signingDate: getSkewCorrectedDate(config.systemClockOffset),
-      signingRegion: multiRegionOverride,
-      signingService: signingName
-    });
-    return signedRequest;
-  }
-};
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getArrayForCommaSeparatedString.js
-var getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : [];
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getBearerTokenEnvKey.js
-var getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`;
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/NODE_AUTH_SCHEME_PREFERENCE_OPTIONS.js
-var NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE";
-var NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference";
-var NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = {
-  environmentVariableSelector: (env2, options) => {
-    if (options?.signingName) {
-      const bearerTokenKey = getBearerTokenEnvKey(options.signingName);
-      if (bearerTokenKey in env2)
-        return ["httpBearerAuth"];
-    }
-    if (!(NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY in env2))
-      return void 0;
-    return getArrayForCommaSeparatedString(env2[NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY]);
-  },
-  configFileSelector: (profile) => {
-    if (!(NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY in profile))
-      return void 0;
-    return getArrayForCommaSeparatedString(profile[NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY]);
-  },
-  default: []
-};
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4AConfig.js
-var resolveAwsSdkSigV4AConfig = (config) => {
-  config.sigv4aSigningRegionSet = normalizeProvider2(config.sigv4aSigningRegionSet);
-  return config;
-};
-var NODE_SIGV4A_CONFIG_OPTIONS = {
-  environmentVariableSelector(env2) {
-    if (env2.AWS_SIGV4A_SIGNING_REGION_SET) {
-      return env2.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((_) => _.trim());
-    }
-    throw new ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", {
-      tryNextLink: true
-    });
-  },
-  configFileSelector(profile) {
-    if (profile.sigv4a_signing_region_set) {
-      return (profile.sigv4a_signing_region_set ?? "").split(",").map((_) => _.trim());
-    }
-    throw new ProviderError("sigv4a_signing_region_set not set in profile.", {
-      tryNextLink: true
-    });
-  },
-  default: void 0
-};
-
-// node_modules/@smithy/signature-v4/dist-es/constants.js
-var ALGORITHM_QUERY_PARAM = "X-Amz-Algorithm";
-var CREDENTIAL_QUERY_PARAM = "X-Amz-Credential";
-var AMZ_DATE_QUERY_PARAM = "X-Amz-Date";
-var SIGNED_HEADERS_QUERY_PARAM = "X-Amz-SignedHeaders";
-var EXPIRES_QUERY_PARAM = "X-Amz-Expires";
-var SIGNATURE_QUERY_PARAM = "X-Amz-Signature";
-var TOKEN_QUERY_PARAM = "X-Amz-Security-Token";
-var AUTH_HEADER = "authorization";
-var AMZ_DATE_HEADER = AMZ_DATE_QUERY_PARAM.toLowerCase();
-var DATE_HEADER = "date";
-var GENERATED_HEADERS = [AUTH_HEADER, AMZ_DATE_HEADER, DATE_HEADER];
-var SIGNATURE_HEADER = SIGNATURE_QUERY_PARAM.toLowerCase();
-var SHA256_HEADER = "x-amz-content-sha256";
-var TOKEN_HEADER = TOKEN_QUERY_PARAM.toLowerCase();
-var ALWAYS_UNSIGNABLE_HEADERS = {
-  authorization: true,
-  "cache-control": true,
-  connection: true,
-  expect: true,
-  from: true,
-  "keep-alive": true,
-  "max-forwards": true,
-  pragma: true,
-  referer: true,
-  te: true,
-  trailer: true,
-  "transfer-encoding": true,
-  upgrade: true,
-  "user-agent": true,
-  "x-amzn-trace-id": true
-};
-var PROXY_HEADER_PATTERN = /^proxy-/;
-var SEC_HEADER_PATTERN = /^sec-/;
-var ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256";
-var EVENT_ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256-PAYLOAD";
-var UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
-var MAX_CACHE_SIZE = 50;
-var KEY_TYPE_IDENTIFIER = "aws4_request";
-var MAX_PRESIGNED_TTL = 60 * 60 * 24 * 7;
-
-// node_modules/@smithy/signature-v4/dist-es/credentialDerivation.js
-var signingKeyCache = {};
-var cacheQueue = [];
-var createScope = (shortDate, region, service) => `${shortDate}/${region}/${service}/${KEY_TYPE_IDENTIFIER}`;
-var getSigningKey = async (sha256Constructor, credentials, shortDate, region, service) => {
-  const credsHash = await hmac(sha256Constructor, credentials.secretAccessKey, credentials.accessKeyId);
-  const cacheKey = `${shortDate}:${region}:${service}:${toHex(credsHash)}:${credentials.sessionToken}`;
-  if (cacheKey in signingKeyCache) {
-    return signingKeyCache[cacheKey];
-  }
-  cacheQueue.push(cacheKey);
-  while (cacheQueue.length > MAX_CACHE_SIZE) {
-    delete signingKeyCache[cacheQueue.shift()];
-  }
-  let key = `AWS4${credentials.secretAccessKey}`;
-  for (const signable of [shortDate, region, service, KEY_TYPE_IDENTIFIER]) {
-    key = await hmac(sha256Constructor, key, signable);
-  }
-  return signingKeyCache[cacheKey] = key;
-};
-var hmac = (ctor, secret, data) => {
-  const hash = new ctor(secret);
-  hash.update(toUint8Array(data));
-  return hash.digest();
-};
-
-// node_modules/@smithy/signature-v4/dist-es/getCanonicalHeaders.js
-var getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
-  const canonical = {};
-  for (const headerName of Object.keys(headers).sort()) {
-    if (headers[headerName] == void 0) {
-      continue;
-    }
-    const canonicalHeaderName = headerName.toLowerCase();
-    if (canonicalHeaderName in ALWAYS_UNSIGNABLE_HEADERS || unsignableHeaders?.has(canonicalHeaderName) || PROXY_HEADER_PATTERN.test(canonicalHeaderName) || SEC_HEADER_PATTERN.test(canonicalHeaderName)) {
-      if (!signableHeaders || signableHeaders && !signableHeaders.has(canonicalHeaderName)) {
-        continue;
-      }
-    }
-    canonical[canonicalHeaderName] = headers[headerName].trim().replace(/\s+/g, " ");
-  }
-  return canonical;
-};
-
-// node_modules/@smithy/signature-v4/dist-es/getPayloadHash.js
-var getPayloadHash = async ({ headers, body }, hashConstructor) => {
-  for (const headerName of Object.keys(headers)) {
-    if (headerName.toLowerCase() === SHA256_HEADER) {
-      return headers[headerName];
-    }
-  }
-  if (body == void 0) {
-    return "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
-  } else if (typeof body === "string" || ArrayBuffer.isView(body) || isArrayBuffer(body)) {
-    const hashCtor = new hashConstructor();
-    hashCtor.update(toUint8Array(body));
-    return toHex(await hashCtor.digest());
-  }
-  return UNSIGNED_PAYLOAD;
-};
-
-// node_modules/@smithy/signature-v4/dist-es/HeaderFormatter.js
-var HeaderFormatter = class {
-  format(headers) {
-    const chunks = [];
-    for (const headerName of Object.keys(headers)) {
-      const bytes = fromUtf8(headerName);
-      chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
-    }
-    const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
-    let position = 0;
-    for (const chunk of chunks) {
-      out.set(chunk, position);
-      position += chunk.byteLength;
-    }
-    return out;
-  }
-  formatHeaderValue(header) {
-    switch (header.type) {
-      case "boolean":
-        return Uint8Array.from([header.value ? 0 : 1]);
-      case "byte":
-        return Uint8Array.from([2, header.value]);
-      case "short":
-        const shortView = new DataView(new ArrayBuffer(3));
-        shortView.setUint8(0, 3);
-        shortView.setInt16(1, header.value, false);
-        return new Uint8Array(shortView.buffer);
-      case "integer":
-        const intView = new DataView(new ArrayBuffer(5));
-        intView.setUint8(0, 4);
-        intView.setInt32(1, header.value, false);
-        return new Uint8Array(intView.buffer);
-      case "long":
-        const longBytes = new Uint8Array(9);
-        longBytes[0] = 5;
-        longBytes.set(header.value.bytes, 1);
-        return longBytes;
-      case "binary":
-        const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
-        binView.setUint8(0, 6);
-        binView.setUint16(1, header.value.byteLength, false);
-        const binBytes = new Uint8Array(binView.buffer);
-        binBytes.set(header.value, 3);
-        return binBytes;
-      case "string":
-        const utf8Bytes = fromUtf8(header.value);
-        const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
-        strView.setUint8(0, 7);
-        strView.setUint16(1, utf8Bytes.byteLength, false);
-        const strBytes = new Uint8Array(strView.buffer);
-        strBytes.set(utf8Bytes, 3);
-        return strBytes;
-      case "timestamp":
-        const tsBytes = new Uint8Array(9);
-        tsBytes[0] = 8;
-        tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
-        return tsBytes;
-      case "uuid":
-        if (!UUID_PATTERN.test(header.value)) {
-          throw new Error(`Invalid UUID received: ${header.value}`);
-        }
-        const uuidBytes = new Uint8Array(17);
-        uuidBytes[0] = 9;
-        uuidBytes.set(fromHex(header.value.replace(/\-/g, "")), 1);
-        return uuidBytes;
-    }
-  }
-};
-var HEADER_VALUE_TYPE;
-(function(HEADER_VALUE_TYPE2) {
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["boolTrue"] = 0] = "boolTrue";
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["boolFalse"] = 1] = "boolFalse";
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["byte"] = 2] = "byte";
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["short"] = 3] = "short";
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["integer"] = 4] = "integer";
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["long"] = 5] = "long";
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["byteArray"] = 6] = "byteArray";
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["string"] = 7] = "string";
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["timestamp"] = 8] = "timestamp";
-  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["uuid"] = 9] = "uuid";
-})(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
-var UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
-var Int64 = class _Int64 {
-  bytes;
-  constructor(bytes) {
-    this.bytes = bytes;
-    if (bytes.byteLength !== 8) {
-      throw new Error("Int64 buffers must be exactly 8 bytes");
-    }
-  }
-  static fromNumber(number) {
-    if (number > 9223372036854776e3 || number < -9223372036854776e3) {
-      throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
-    }
-    const bytes = new Uint8Array(8);
-    for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) {
-      bytes[i] = remaining;
-    }
-    if (number < 0) {
-      negate(bytes);
-    }
-    return new _Int64(bytes);
-  }
-  valueOf() {
-    const bytes = this.bytes.slice(0);
-    const negative = bytes[0] & 128;
-    if (negative) {
-      negate(bytes);
-    }
-    return parseInt(toHex(bytes), 16) * (negative ? -1 : 1);
-  }
-  toString() {
-    return String(this.valueOf());
-  }
-};
-function negate(bytes) {
-  for (let i = 0; i < 8; i++) {
-    bytes[i] ^= 255;
-  }
-  for (let i = 7; i > -1; i--) {
-    bytes[i]++;
-    if (bytes[i] !== 0)
-      break;
-  }
-}
-
-// node_modules/@smithy/signature-v4/dist-es/headerUtil.js
-var hasHeader = (soughtHeader, headers) => {
-  soughtHeader = soughtHeader.toLowerCase();
-  for (const headerName of Object.keys(headers)) {
-    if (soughtHeader === headerName.toLowerCase()) {
-      return true;
-    }
-  }
-  return false;
-};
-
-// node_modules/@smithy/signature-v4/dist-es/moveHeadersToQuery.js
-var moveHeadersToQuery = (request, options = {}) => {
-  const { headers, query = {} } = HttpRequest.clone(request);
-  for (const name of Object.keys(headers)) {
-    const lname = name.toLowerCase();
-    if (lname.slice(0, 6) === "x-amz-" && !options.unhoistableHeaders?.has(lname) || options.hoistableHeaders?.has(lname)) {
-      query[name] = headers[name];
-      delete headers[name];
-    }
-  }
-  return {
-    ...request,
-    headers,
-    query
-  };
-};
-
-// node_modules/@smithy/signature-v4/dist-es/prepareRequest.js
-var prepareRequest = (request) => {
-  request = HttpRequest.clone(request);
-  for (const headerName of Object.keys(request.headers)) {
-    if (GENERATED_HEADERS.indexOf(headerName.toLowerCase()) > -1) {
-      delete request.headers[headerName];
-    }
-  }
-  return request;
-};
-
-// node_modules/@smithy/signature-v4/dist-es/getCanonicalQuery.js
-var getCanonicalQuery = ({ query = {} }) => {
-  const keys = [];
-  const serialized = {};
-  for (const key of Object.keys(query)) {
-    if (key.toLowerCase() === SIGNATURE_HEADER) {
-      continue;
-    }
-    const encodedKey = escapeUri(key);
-    keys.push(encodedKey);
-    const value = query[key];
-    if (typeof value === "string") {
-      serialized[encodedKey] = `${encodedKey}=${escapeUri(value)}`;
-    } else if (Array.isArray(value)) {
-      serialized[encodedKey] = value.slice(0).reduce((encoded, value2) => encoded.concat([`${encodedKey}=${escapeUri(value2)}`]), []).sort().join("&");
-    }
-  }
-  return keys.sort().map((key) => serialized[key]).filter((serialized2) => serialized2).join("&");
-};
-
-// node_modules/@smithy/signature-v4/dist-es/utilDate.js
-var iso8601 = (time) => toDate(time).toISOString().replace(/\.\d{3}Z$/, "Z");
-var toDate = (time) => {
-  if (typeof time === "number") {
-    return new Date(time * 1e3);
-  }
-  if (typeof time === "string") {
-    if (Number(time)) {
-      return new Date(Number(time) * 1e3);
-    }
-    return new Date(time);
-  }
-  return time;
-};
-
-// node_modules/@smithy/signature-v4/dist-es/SignatureV4Base.js
-var SignatureV4Base = class {
-  service;
-  regionProvider;
-  credentialProvider;
-  sha256;
-  uriEscapePath;
-  applyChecksum;
-  constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
-    this.service = service;
-    this.sha256 = sha256;
-    this.uriEscapePath = uriEscapePath;
-    this.applyChecksum = typeof applyChecksum === "boolean" ? applyChecksum : true;
-    this.regionProvider = normalizeProvider(region);
-    this.credentialProvider = normalizeProvider(credentials);
-  }
-  createCanonicalRequest(request, canonicalHeaders, payloadHash) {
-    const sortedHeaders = Object.keys(canonicalHeaders).sort();
-    return `${request.method}
-${this.getCanonicalPath(request)}
-${getCanonicalQuery(request)}
-${sortedHeaders.map((name) => `${name}:${canonicalHeaders[name]}`).join("\n")}
-
-${sortedHeaders.join(";")}
-${payloadHash}`;
-  }
-  async createStringToSign(longDate, credentialScope, canonicalRequest, algorithmIdentifier) {
-    const hash = new this.sha256();
-    hash.update(toUint8Array(canonicalRequest));
-    const hashedRequest = await hash.digest();
-    return `${algorithmIdentifier}
-${longDate}
-${credentialScope}
-${toHex(hashedRequest)}`;
-  }
-  getCanonicalPath({ path }) {
-    if (this.uriEscapePath) {
-      const normalizedPathSegments = [];
-      for (const pathSegment of path.split("/")) {
-        if (pathSegment?.length === 0)
-          continue;
-        if (pathSegment === ".")
-          continue;
-        if (pathSegment === "..") {
-          normalizedPathSegments.pop();
-        } else {
-          normalizedPathSegments.push(pathSegment);
-        }
-      }
-      const normalizedPath = `${path?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path?.endsWith("/") ? "/" : ""}`;
-      const doubleEncoded = escapeUri(normalizedPath);
-      return doubleEncoded.replace(/%2F/g, "/");
-    }
-    return path;
-  }
-  validateResolvedCredentials(credentials) {
-    if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
-      throw new Error("Resolved credential object is not valid");
-    }
-  }
-  formatDate(now) {
-    const longDate = iso8601(now).replace(/[\-:]/g, "");
-    return {
-      longDate,
-      shortDate: longDate.slice(0, 8)
-    };
-  }
-  getCanonicalHeaderList(headers) {
-    return Object.keys(headers).sort().join(";");
-  }
-};
-
-// node_modules/@smithy/signature-v4/dist-es/SignatureV4.js
-var SignatureV4 = class extends SignatureV4Base {
-  headerFormatter = new HeaderFormatter();
-  constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
-    super({
-      applyChecksum,
-      credentials,
-      region,
-      service,
-      sha256,
-      uriEscapePath
-    });
-  }
-  async presign(originalRequest, options = {}) {
-    const { signingDate = /* @__PURE__ */ new Date(), expiresIn = 3600, unsignableHeaders, unhoistableHeaders, signableHeaders, hoistableHeaders, signingRegion, signingService } = options;
-    const credentials = await this.credentialProvider();
-    this.validateResolvedCredentials(credentials);
-    const region = signingRegion ?? await this.regionProvider();
-    const { longDate, shortDate } = this.formatDate(signingDate);
-    if (expiresIn > MAX_PRESIGNED_TTL) {
-      return Promise.reject("Signature version 4 presigned URLs must have an expiration date less than one week in the future");
-    }
-    const scope = createScope(shortDate, region, signingService ?? this.service);
-    const request = moveHeadersToQuery(prepareRequest(originalRequest), { unhoistableHeaders, hoistableHeaders });
-    if (credentials.sessionToken) {
-      request.query[TOKEN_QUERY_PARAM] = credentials.sessionToken;
-    }
-    request.query[ALGORITHM_QUERY_PARAM] = ALGORITHM_IDENTIFIER;
-    request.query[CREDENTIAL_QUERY_PARAM] = `${credentials.accessKeyId}/${scope}`;
-    request.query[AMZ_DATE_QUERY_PARAM] = longDate;
-    request.query[EXPIRES_QUERY_PARAM] = expiresIn.toString(10);
-    const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
-    request.query[SIGNED_HEADERS_QUERY_PARAM] = this.getCanonicalHeaderList(canonicalHeaders);
-    request.query[SIGNATURE_QUERY_PARAM] = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, await getPayloadHash(originalRequest, this.sha256)));
-    return request;
-  }
-  async sign(toSign, options) {
-    if (typeof toSign === "string") {
-      return this.signString(toSign, options);
-    } else if (toSign.headers && toSign.payload) {
-      return this.signEvent(toSign, options);
-    } else if (toSign.message) {
-      return this.signMessage(toSign, options);
-    } else {
-      return this.signRequest(toSign, options);
-    }
-  }
-  async signEvent({ headers, payload }, { signingDate = /* @__PURE__ */ new Date(), priorSignature, signingRegion, signingService }) {
-    const region = signingRegion ?? await this.regionProvider();
-    const { shortDate, longDate } = this.formatDate(signingDate);
-    const scope = createScope(shortDate, region, signingService ?? this.service);
-    const hashedPayload = await getPayloadHash({ headers: {}, body: payload }, this.sha256);
-    const hash = new this.sha256();
-    hash.update(headers);
-    const hashedHeaders = toHex(await hash.digest());
-    const stringToSign = [
-      EVENT_ALGORITHM_IDENTIFIER,
-      longDate,
-      scope,
-      priorSignature,
-      hashedHeaders,
-      hashedPayload
-    ].join("\n");
-    return this.signString(stringToSign, { signingDate, signingRegion: region, signingService });
-  }
-  async signMessage(signableMessage, { signingDate = /* @__PURE__ */ new Date(), signingRegion, signingService }) {
-    const promise = this.signEvent({
-      headers: this.headerFormatter.format(signableMessage.message.headers),
-      payload: signableMessage.message.body
-    }, {
-      signingDate,
-      signingRegion,
-      signingService,
-      priorSignature: signableMessage.priorSignature
-    });
-    return promise.then((signature) => {
-      return { message: signableMessage.message, signature };
-    });
-  }
-  async signString(stringToSign, { signingDate = /* @__PURE__ */ new Date(), signingRegion, signingService } = {}) {
-    const credentials = await this.credentialProvider();
-    this.validateResolvedCredentials(credentials);
-    const region = signingRegion ?? await this.regionProvider();
-    const { shortDate } = this.formatDate(signingDate);
-    const hash = new this.sha256(await this.getSigningKey(credentials, region, shortDate, signingService));
-    hash.update(toUint8Array(stringToSign));
-    return toHex(await hash.digest());
-  }
-  async signRequest(requestToSign, { signingDate = /* @__PURE__ */ new Date(), signableHeaders, unsignableHeaders, signingRegion, signingService } = {}) {
-    const credentials = await this.credentialProvider();
-    this.validateResolvedCredentials(credentials);
-    const region = signingRegion ?? await this.regionProvider();
-    const request = prepareRequest(requestToSign);
-    const { longDate, shortDate } = this.formatDate(signingDate);
-    const scope = createScope(shortDate, region, signingService ?? this.service);
-    request.headers[AMZ_DATE_HEADER] = longDate;
-    if (credentials.sessionToken) {
-      request.headers[TOKEN_HEADER] = credentials.sessionToken;
-    }
-    const payloadHash = await getPayloadHash(request, this.sha256);
-    if (!hasHeader(SHA256_HEADER, request.headers) && this.applyChecksum) {
-      request.headers[SHA256_HEADER] = payloadHash;
-    }
-    const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
-    const signature = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, payloadHash));
-    request.headers[AUTH_HEADER] = `${ALGORITHM_IDENTIFIER} Credential=${credentials.accessKeyId}/${scope}, SignedHeaders=${this.getCanonicalHeaderList(canonicalHeaders)}, Signature=${signature}`;
-    return request;
-  }
-  async getSignature(longDate, credentialScope, keyPromise, canonicalRequest) {
-    const stringToSign = await this.createStringToSign(longDate, credentialScope, canonicalRequest, ALGORITHM_IDENTIFIER);
-    const hash = new this.sha256(await keyPromise);
-    hash.update(toUint8Array(stringToSign));
-    return toHex(await hash.digest());
-  }
-  getSigningKey(credentials, region, shortDate, service) {
-    return getSigningKey(this.sha256, credentials, shortDate, region, service || this.service);
-  }
-};
-
-// node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.js
-var resolveAwsSdkSigV4Config = (config) => {
-  let inputCredentials = config.credentials;
-  let isUserSupplied = !!config.credentials;
-  let resolvedCredentials = void 0;
-  Object.defineProperty(config, "credentials", {
-    set(credentials) {
-      if (credentials && credentials !== inputCredentials && credentials !== resolvedCredentials) {
-        isUserSupplied = true;
-      }
-      inputCredentials = credentials;
-      const memoizedProvider = normalizeCredentialProvider(config, {
-        credentials: inputCredentials,
-        credentialDefaultProvider: config.credentialDefaultProvider
-      });
-      const boundProvider = bindCallerConfig(config, memoizedProvider);
-      if (isUserSupplied && !boundProvider.attributed) {
-        resolvedCredentials = async (options) => boundProvider(options).then((creds) => setCredentialFeature(creds, "CREDENTIALS_CODE", "e"));
-        resolvedCredentials.memoized = boundProvider.memoized;
-        resolvedCredentials.configBound = boundProvider.configBound;
-        resolvedCredentials.attributed = true;
-      } else {
-        resolvedCredentials = boundProvider;
-      }
-    },
-    get() {
-      return resolvedCredentials;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  config.credentials = inputCredentials;
-  const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256 } = config;
-  let signer;
-  if (config.signer) {
-    signer = normalizeProvider2(config.signer);
-  } else if (config.regionInfoProvider) {
-    signer = () => normalizeProvider2(config.region)().then(async (region) => [
-      await config.regionInfoProvider(region, {
-        useFipsEndpoint: await config.useFipsEndpoint(),
-        useDualstackEndpoint: await config.useDualstackEndpoint()
-      }) || {},
-      region
-    ]).then(([regionInfo, region]) => {
-      const { signingRegion, signingService } = regionInfo;
-      config.signingRegion = config.signingRegion || signingRegion || region;
-      config.signingName = config.signingName || signingService || config.serviceId;
-      const params = {
-        ...config,
-        credentials: config.credentials,
-        region: config.signingRegion,
-        service: config.signingName,
-        sha256,
-        uriEscapePath: signingEscapePath
-      };
-      const SignerCtor = config.signerConstructor || SignatureV4;
-      return new SignerCtor(params);
-    });
-  } else {
-    signer = async (authScheme) => {
-      authScheme = Object.assign({}, {
-        name: "sigv4",
-        signingName: config.signingName || config.defaultSigningName,
-        signingRegion: await normalizeProvider2(config.region)(),
-        properties: {}
-      }, authScheme);
-      const signingRegion = authScheme.signingRegion;
-      const signingService = authScheme.signingName;
-      config.signingRegion = config.signingRegion || signingRegion;
-      config.signingName = config.signingName || signingService || config.serviceId;
-      const params = {
-        ...config,
-        credentials: config.credentials,
-        region: config.signingRegion,
-        service: config.signingName,
-        sha256,
-        uriEscapePath: signingEscapePath
-      };
-      const SignerCtor = config.signerConstructor || SignatureV4;
-      return new SignerCtor(params);
-    };
-  }
-  const resolvedConfig = Object.assign(config, {
-    systemClockOffset,
-    signingEscapePath,
-    signer
-  });
-  return resolvedConfig;
-};
-function normalizeCredentialProvider(config, { credentials, credentialDefaultProvider }) {
-  let credentialsProvider;
-  if (credentials) {
-    if (!credentials?.memoized) {
-      credentialsProvider = memoizeIdentityProvider(credentials, isIdentityExpired, doesIdentityRequireRefresh);
-    } else {
-      credentialsProvider = credentials;
-    }
-  } else {
-    if (credentialDefaultProvider) {
-      credentialsProvider = normalizeProvider2(credentialDefaultProvider(Object.assign({}, config, {
-        parentClientConfig: config
-      })));
-    } else {
-      credentialsProvider = async () => {
-        throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured.");
-      };
-    }
-  }
-  credentialsProvider.memoized = true;
-  return credentialsProvider;
-}
-function bindCallerConfig(config, credentialsProvider) {
-  if (credentialsProvider.configBound) {
-    return credentialsProvider;
-  }
-  const fn = async (options) => credentialsProvider({ ...options, callerClientConfig: config });
-  fn.memoized = credentialsProvider.memoized;
-  fn.configBound = true;
-  return fn;
-}
-
-// node_modules/@smithy/smithy-client/dist-es/default-error-handler.js
-var throwDefaultError = ({ output, parsedBody, exceptionCtor, errorCode }) => {
-  const $metadata = deserializeMetadata(output);
-  const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : void 0;
-  const response = new exceptionCtor({
-    name: parsedBody?.code || parsedBody?.Code || errorCode || statusCode || "UnknownError",
-    $fault: "client",
-    $metadata
-  });
-  throw decorateServiceException(response, parsedBody);
-};
-var withBaseException = (ExceptionCtor) => {
-  return ({ output, parsedBody, errorCode }) => {
-    throwDefaultError({ output, parsedBody, exceptionCtor: ExceptionCtor, errorCode });
-  };
-};
-var deserializeMetadata = (output) => ({
-  httpStatusCode: output.statusCode,
-  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-  extendedRequestId: output.headers["x-amz-id-2"],
-  cfId: output.headers["x-amz-cf-id"]
-});
-
-// node_modules/@smithy/smithy-client/dist-es/defaults-mode.js
-var loadConfigsForDefaultMode = (mode) => {
-  switch (mode) {
-    case "standard":
-      return {
-        retryMode: "standard",
-        connectionTimeout: 3100
-      };
-    case "in-region":
-      return {
-        retryMode: "standard",
-        connectionTimeout: 1100
-      };
-    case "cross-region":
-      return {
-        retryMode: "standard",
-        connectionTimeout: 3100
-      };
-    case "mobile":
-      return {
-        retryMode: "standard",
-        connectionTimeout: 3e4
-      };
-    default:
-      return {};
-  }
-};
-
-// node_modules/@smithy/smithy-client/dist-es/emitWarningIfUnsupportedVersion.js
-var warningEmitted = false;
-var emitWarningIfUnsupportedVersion2 = (version) => {
-  if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
-    warningEmitted = true;
-  }
-};
-
-// node_modules/@smithy/smithy-client/dist-es/extensions/checksum.js
-var getChecksumConfiguration = (runtimeConfig) => {
-  const checksumAlgorithms = [];
-  for (const id in AlgorithmId) {
-    const algorithmId = AlgorithmId[id];
-    if (runtimeConfig[algorithmId] === void 0) {
-      continue;
-    }
-    checksumAlgorithms.push({
-      algorithmId: () => algorithmId,
-      checksumConstructor: () => runtimeConfig[algorithmId]
-    });
-  }
-  return {
-    addChecksumAlgorithm(algo) {
-      checksumAlgorithms.push(algo);
-    },
-    checksumAlgorithms() {
-      return checksumAlgorithms;
-    }
-  };
-};
-var resolveChecksumRuntimeConfig = (clientConfig) => {
-  const runtimeConfig = {};
-  clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
-    runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
-  });
-  return runtimeConfig;
-};
-
-// node_modules/@smithy/smithy-client/dist-es/extensions/retry.js
-var getRetryConfiguration = (runtimeConfig) => {
-  return {
-    setRetryStrategy(retryStrategy) {
-      runtimeConfig.retryStrategy = retryStrategy;
-    },
-    retryStrategy() {
-      return runtimeConfig.retryStrategy;
-    }
-  };
-};
-var resolveRetryRuntimeConfig = (retryStrategyConfiguration) => {
-  const runtimeConfig = {};
-  runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy();
-  return runtimeConfig;
-};
-
-// node_modules/@smithy/smithy-client/dist-es/extensions/defaultExtensionConfiguration.js
-var getDefaultExtensionConfiguration = (runtimeConfig) => {
-  return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));
-};
-var resolveDefaultRuntimeConfig = (config) => {
-  return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config));
-};
-
-// node_modules/@smithy/smithy-client/dist-es/NoOpLogger.js
-var NoOpLogger = class {
-  trace() {
-  }
-  debug() {
-  }
-  info() {
-  }
-  warn() {
-  }
-  error() {
-  }
-};
-
-// node_modules/@aws-sdk/core/dist-es/submodules/protocols/common.js
-var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
-
-// node_modules/@aws-sdk/middleware-user-agent/dist-es/check-features.js
-var ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
-async function checkFeatures(context, config, args) {
-  const request = args.request;
-  if (request?.headers?.["smithy-protocol"] === "rpc-v2-cbor") {
-    setFeature2(context, "PROTOCOL_RPC_V2_CBOR", "M");
-  }
-  if (typeof config.retryStrategy === "function") {
-    const retryStrategy = await config.retryStrategy();
-    if (typeof retryStrategy.acquireInitialRetryToken === "function") {
-      if (retryStrategy.constructor?.name?.includes("Adaptive")) {
-        setFeature2(context, "RETRY_MODE_ADAPTIVE", "F");
-      } else {
-        setFeature2(context, "RETRY_MODE_STANDARD", "E");
-      }
-    } else {
-      setFeature2(context, "RETRY_MODE_LEGACY", "D");
-    }
-  }
-  if (typeof config.accountIdEndpointMode === "function") {
-    const endpointV2 = context.endpointV2;
-    if (String(endpointV2?.url?.hostname).match(ACCOUNT_ID_ENDPOINT_REGEX)) {
-      setFeature2(context, "ACCOUNT_ID_ENDPOINT", "O");
-    }
-    switch (await config.accountIdEndpointMode?.()) {
-      case "disabled":
-        setFeature2(context, "ACCOUNT_ID_MODE_DISABLED", "Q");
-        break;
-      case "preferred":
-        setFeature2(context, "ACCOUNT_ID_MODE_PREFERRED", "P");
-        break;
-      case "required":
-        setFeature2(context, "ACCOUNT_ID_MODE_REQUIRED", "R");
-        break;
-    }
-  }
-  const identity = context.__smithy_context?.selectedHttpAuthScheme?.identity;
-  if (identity?.$source) {
-    const credentials = identity;
-    if (credentials.accountId) {
-      setFeature2(context, "RESOLVED_ACCOUNT_ID", "T");
-    }
-    for (const [key, value] of Object.entries(credentials.$source ?? {})) {
-      setFeature2(context, key, value);
-    }
-  }
-}
-
-// node_modules/@aws-sdk/middleware-user-agent/dist-es/constants.js
-var USER_AGENT = "user-agent";
-var X_AMZ_USER_AGENT = "x-amz-user-agent";
-var SPACE = " ";
-var UA_NAME_SEPARATOR = "/";
-var UA_NAME_ESCAPE_REGEX = /[^\!\$\%\&\'\*\+\-\.\^\_\`\|\~\d\w]/g;
-var UA_VALUE_ESCAPE_REGEX = /[^\!\$\%\&\'\*\+\-\.\^\_\`\|\~\d\w\#]/g;
-var UA_ESCAPE_CHAR = "-";
-
-// node_modules/@aws-sdk/middleware-user-agent/dist-es/encode-features.js
-var BYTE_LIMIT = 1024;
-function encodeFeatures(features) {
-  let buffer = "";
-  for (const key in features) {
-    const val = features[key];
-    if (buffer.length + val.length + 1 <= BYTE_LIMIT) {
-      if (buffer.length) {
-        buffer += "," + val;
-      } else {
-        buffer += val;
-      }
-      continue;
-    }
-    break;
-  }
-  return buffer;
-}
-
-// node_modules/@aws-sdk/middleware-user-agent/dist-es/user-agent-middleware.js
-var userAgentMiddleware = (options) => (next, context) => async (args) => {
-  const { request } = args;
-  if (!HttpRequest.isInstance(request)) {
-    return next(args);
-  }
-  const { headers } = request;
-  const userAgent = context?.userAgent?.map(escapeUserAgent) || [];
-  const defaultUserAgent = (await options.defaultUserAgentProvider()).map(escapeUserAgent);
-  await checkFeatures(context, options, args);
-  const awsContext = context;
-  defaultUserAgent.push(`m/${encodeFeatures(Object.assign({}, context.__smithy_context?.features, awsContext.__aws_sdk_context?.features))}`);
-  const customUserAgent = options?.customUserAgent?.map(escapeUserAgent) || [];
-  const appId = await options.userAgentAppId();
-  if (appId) {
-    defaultUserAgent.push(escapeUserAgent([`app/${appId}`]));
-  }
-  const prefix = getUserAgentPrefix();
-  const sdkUserAgentValue = (prefix ? [prefix] : []).concat([...defaultUserAgent, ...userAgent, ...customUserAgent]).join(SPACE);
-  const normalUAValue = [
-    ...defaultUserAgent.filter((section) => section.startsWith("aws-sdk-")),
-    ...customUserAgent
-  ].join(SPACE);
-  if (options.runtime !== "browser") {
-    if (normalUAValue) {
-      headers[X_AMZ_USER_AGENT] = headers[X_AMZ_USER_AGENT] ? `${headers[USER_AGENT]} ${normalUAValue}` : normalUAValue;
-    }
-    headers[USER_AGENT] = sdkUserAgentValue;
-  } else {
-    headers[X_AMZ_USER_AGENT] = sdkUserAgentValue;
-  }
-  return next({
-    ...args,
-    request
-  });
-};
-var escapeUserAgent = (userAgentPair) => {
-  const name = userAgentPair[0].split(UA_NAME_SEPARATOR).map((part) => part.replace(UA_NAME_ESCAPE_REGEX, UA_ESCAPE_CHAR)).join(UA_NAME_SEPARATOR);
-  const version = userAgentPair[1]?.replace(UA_VALUE_ESCAPE_REGEX, UA_ESCAPE_CHAR);
-  const prefixSeparatorIndex = name.indexOf(UA_NAME_SEPARATOR);
-  const prefix = name.substring(0, prefixSeparatorIndex);
-  let uaName = name.substring(prefixSeparatorIndex + 1);
-  if (prefix === "api") {
-    uaName = uaName.toLowerCase();
-  }
-  return [prefix, uaName, version].filter((item) => item && item.length > 0).reduce((acc, item, index) => {
-    switch (index) {
-      case 0:
-        return item;
-      case 1:
-        return `${acc}/${item}`;
-      default:
-        return `${acc}#${item}`;
-    }
-  }, "");
-};
-var getUserAgentMiddlewareOptions = {
-  name: "getUserAgentMiddleware",
-  step: "build",
-  priority: "low",
-  tags: ["SET_USER_AGENT", "USER_AGENT"],
-  override: true
-};
-var getUserAgentPlugin = (config) => ({
-  applyToStack: (clientStack) => {
-    clientStack.add(userAgentMiddleware(config), getUserAgentMiddlewareOptions);
-  }
-});
-
-// node_modules/@smithy/config-resolver/dist-es/regionConfig/checkRegion.js
-var validRegions = /* @__PURE__ */ new Set();
-var checkRegion = (region, check = isValidHostLabel) => {
-  if (!validRegions.has(region) && !check(region)) {
-    if (region === "*") {
-      console.warn(`@smithy/config-resolver WARN - Please use the caller region instead of "*". See "sigv4a" in https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md.`);
-    } else {
-      throw new Error(`Region not accepted: region="${region}" is not a valid hostname component.`);
-    }
-  } else {
-    validRegions.add(region);
-  }
-};
-
-// node_modules/@smithy/config-resolver/dist-es/regionConfig/isFipsRegion.js
-var isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));
-
-// node_modules/@smithy/config-resolver/dist-es/regionConfig/getRealRegion.js
-var getRealRegion = (region) => isFipsRegion(region) ? ["fips-aws-global", "aws-fips"].includes(region) ? "us-east-1" : region.replace(/fips-(dkr-|prod-)?|-fips/, "") : region;
-
-// node_modules/@smithy/config-resolver/dist-es/regionConfig/resolveRegionConfig.js
-var resolveRegionConfig = (input) => {
-  const { region, useFipsEndpoint } = input;
-  if (!region) {
-    throw new Error("Region is missing");
-  }
-  return Object.assign(input, {
-    region: async () => {
-      const providedRegion = typeof region === "function" ? await region() : region;
-      const realRegion = getRealRegion(providedRegion);
-      checkRegion(realRegion);
-      return realRegion;
-    },
-    useFipsEndpoint: async () => {
-      const providedRegion = typeof region === "string" ? region : await region();
-      if (isFipsRegion(providedRegion)) {
-        return true;
-      }
-      return typeof useFipsEndpoint !== "function" ? Promise.resolve(!!useFipsEndpoint) : useFipsEndpoint();
-    }
-  });
-};
-
-// node_modules/@smithy/middleware-content-length/dist-es/index.js
-var CONTENT_LENGTH_HEADER = "content-length";
-function contentLengthMiddleware(bodyLengthChecker) {
-  return (next) => async (args) => {
-    const request = args.request;
-    if (HttpRequest.isInstance(request)) {
-      const { body, headers } = request;
-      if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf(CONTENT_LENGTH_HEADER) === -1) {
-        try {
-          const length = bodyLengthChecker(body);
-          request.headers = {
-            ...request.headers,
-            [CONTENT_LENGTH_HEADER]: String(length)
-          };
-        } catch (error) {
-        }
-      }
-    }
-    return next({
-      ...args,
-      request
-    });
-  };
-}
-var contentLengthMiddlewareOptions = {
-  step: "build",
-  tags: ["SET_CONTENT_LENGTH", "CONTENT_LENGTH"],
-  name: "contentLengthMiddleware",
-  override: true
-};
-var getContentLengthPlugin = (options) => ({
-  applyToStack: (clientStack) => {
-    clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), contentLengthMiddlewareOptions);
-  }
-});
-
-// node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/s3.js
-var resolveParamsForS3 = async (endpointParams) => {
-  const bucket = endpointParams?.Bucket || "";
-  if (typeof endpointParams.Bucket === "string") {
-    endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
-  }
-  if (isArnBucketName(bucket)) {
-    if (endpointParams.ForcePathStyle === true) {
-      throw new Error("Path-style addressing cannot be used with ARN buckets");
-    }
-  } else if (!isDnsCompatibleBucketName(bucket) || bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:") || bucket.toLowerCase() !== bucket || bucket.length < 3) {
-    endpointParams.ForcePathStyle = true;
-  }
-  if (endpointParams.DisableMultiRegionAccessPoints) {
-    endpointParams.disableMultiRegionAccessPoints = true;
-    endpointParams.DisableMRAP = true;
-  }
-  return endpointParams;
-};
-var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
-var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
-var DOTS_PATTERN = /\.\./;
-var isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
-var isArnBucketName = (bucketName) => {
-  const [arn, partition2, service, , , bucket] = bucketName.split(":");
-  const isArn = arn === "arn" && bucketName.split(":").length >= 6;
-  const isValidArn = Boolean(isArn && partition2 && service && bucket);
-  if (isArn && !isValidArn) {
-    throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
-  }
-  return isValidArn;
-};
-
-// node_modules/@smithy/middleware-endpoint/dist-es/adaptors/createConfigValueProvider.js
-var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config, isClientContextParam = false) => {
-  const configProvider = async () => {
-    let configValue;
-    if (isClientContextParam) {
-      const clientContextParams = config.clientContextParams;
-      const nestedValue = clientContextParams?.[configKey];
-      configValue = nestedValue ?? config[configKey] ?? config[canonicalEndpointParamKey];
-    } else {
-      configValue = config[configKey] ?? config[canonicalEndpointParamKey];
-    }
-    if (typeof configValue === "function") {
-      return configValue();
-    }
-    return configValue;
-  };
-  if (configKey === "credentialScope" || canonicalEndpointParamKey === "CredentialScope") {
-    return async () => {
-      const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
-      const configValue = credentials?.credentialScope ?? credentials?.CredentialScope;
-      return configValue;
-    };
-  }
-  if (configKey === "accountId" || canonicalEndpointParamKey === "AccountId") {
-    return async () => {
-      const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
-      const configValue = credentials?.accountId ?? credentials?.AccountId;
-      return configValue;
-    };
-  }
-  if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
-    return async () => {
-      if (config.isCustomEndpoint === false) {
-        return void 0;
-      }
-      const endpoint = await configProvider();
-      if (endpoint && typeof endpoint === "object") {
-        if ("url" in endpoint) {
-          return endpoint.url.href;
-        }
-        if ("hostname" in endpoint) {
-          const { protocol, hostname, port, path } = endpoint;
-          return `${protocol}//${hostname}${port ? ":" + port : ""}${path}`;
-        }
-      }
-      return endpoint;
-    };
-  }
-  return configProvider;
-};
-
-// node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointUrlConfig.js
-var ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
-var CONFIG_ENDPOINT_URL = "endpoint_url";
-var getEndpointUrlConfig = (serviceId) => ({
-  environmentVariableSelector: (env2) => {
-    const serviceSuffixParts = serviceId.split(" ").map((w) => w.toUpperCase());
-    const serviceEndpointUrl = env2[[ENV_ENDPOINT_URL, ...serviceSuffixParts].join("_")];
-    if (serviceEndpointUrl)
-      return serviceEndpointUrl;
-    const endpointUrl = env2[ENV_ENDPOINT_URL];
-    if (endpointUrl)
-      return endpointUrl;
-    return void 0;
-  },
-  configFileSelector: (profile, config) => {
-    if (config && profile.services) {
-      const servicesSection = config[["services", profile.services].join(CONFIG_PREFIX_SEPARATOR)];
-      if (servicesSection) {
-        const servicePrefixParts = serviceId.split(" ").map((w) => w.toLowerCase());
-        const endpointUrl2 = servicesSection[[servicePrefixParts.join("_"), CONFIG_ENDPOINT_URL].join(CONFIG_PREFIX_SEPARATOR)];
-        if (endpointUrl2)
-          return endpointUrl2;
-      }
-    }
-    const endpointUrl = profile[CONFIG_ENDPOINT_URL];
-    if (endpointUrl)
-      return endpointUrl;
-    return void 0;
-  },
-  default: void 0
-});
-
-// node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromConfig.js
-var getEndpointFromConfig = async (serviceId) => loadConfig(getEndpointUrlConfig(serviceId ?? ""))();
-
-// node_modules/@smithy/middleware-endpoint/dist-es/adaptors/toEndpointV1.js
-var toEndpointV1 = (endpoint) => {
-  if (typeof endpoint === "object") {
-    if ("url" in endpoint) {
-      return parseUrl(endpoint.url);
-    }
-    return endpoint;
-  }
-  return parseUrl(endpoint);
-};
-
-// node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromInstructions.js
-var getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
-  if (!clientConfig.isCustomEndpoint) {
-    let endpointFromConfig;
-    if (clientConfig.serviceConfiguredEndpoint) {
-      endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
-    } else {
-      endpointFromConfig = await getEndpointFromConfig(clientConfig.serviceId);
-    }
-    if (endpointFromConfig) {
-      clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
-      clientConfig.isCustomEndpoint = true;
-    }
-  }
-  const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig);
-  if (typeof clientConfig.endpointProvider !== "function") {
-    throw new Error("config.endpointProvider is not set.");
-  }
-  const endpoint = clientConfig.endpointProvider(endpointParams, context);
-  return endpoint;
-};
-var resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
-  const endpointParams = {};
-  const instructions = instructionsSupplier?.getEndpointParameterInstructions?.() || {};
-  for (const [name, instruction] of Object.entries(instructions)) {
-    switch (instruction.type) {
-      case "staticContextParams":
-        endpointParams[name] = instruction.value;
-        break;
-      case "contextParams":
-        endpointParams[name] = commandInput[instruction.name];
-        break;
-      case "clientContextParams":
-      case "builtInParams":
-        endpointParams[name] = await createConfigValueProvider(instruction.name, name, clientConfig, instruction.type !== "builtInParams")();
-        break;
-      case "operationContextParams":
-        endpointParams[name] = instruction.get(commandInput);
-        break;
-      default:
-        throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
-    }
-  }
-  if (Object.keys(instructions).length === 0) {
-    Object.assign(endpointParams, clientConfig);
-  }
-  if (String(clientConfig.serviceId).toLowerCase() === "s3") {
-    await resolveParamsForS3(endpointParams);
-  }
-  return endpointParams;
-};
-
-// node_modules/@smithy/middleware-endpoint/dist-es/endpointMiddleware.js
-var endpointMiddleware = ({ config, instructions }) => {
-  return (next, context) => async (args) => {
-    if (config.isCustomEndpoint) {
-      setFeature(context, "ENDPOINT_OVERRIDE", "N");
-    }
-    const endpoint = await getEndpointFromInstructions(args.input, {
-      getEndpointParameterInstructions() {
-        return instructions;
-      }
-    }, { ...config }, context);
-    context.endpointV2 = endpoint;
-    context.authSchemes = endpoint.properties?.authSchemes;
-    const authScheme = context.authSchemes?.[0];
-    if (authScheme) {
-      context["signing_region"] = authScheme.signingRegion;
-      context["signing_service"] = authScheme.signingName;
-      const smithyContext = getSmithyContext(context);
-      const httpAuthOption = smithyContext?.selectedHttpAuthScheme?.httpAuthOption;
-      if (httpAuthOption) {
-        httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, {
-          signing_region: authScheme.signingRegion,
-          signingRegion: authScheme.signingRegion,
-          signing_service: authScheme.signingName,
-          signingName: authScheme.signingName,
-          signingRegionSet: authScheme.signingRegionSet
-        }, authScheme.properties);
-      }
-    }
-    return next({
-      ...args
-    });
-  };
-};
-
-// node_modules/@smithy/middleware-endpoint/dist-es/getEndpointPlugin.js
-var endpointMiddlewareOptions = {
-  step: "serialize",
-  tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
-  name: "endpointV2Middleware",
-  override: true,
-  relation: "before",
-  toMiddleware: serializerMiddlewareOption.name
-};
-var getEndpointPlugin = (config, instructions) => ({
-  applyToStack: (clientStack) => {
-    clientStack.addRelativeTo(endpointMiddleware({
-      config,
-      instructions
-    }), endpointMiddlewareOptions);
-  }
-});
-
-// node_modules/@smithy/middleware-endpoint/dist-es/resolveEndpointConfig.js
-var resolveEndpointConfig = (input) => {
-  const tls = input.tls ?? true;
-  const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input;
-  const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await normalizeProvider(endpoint)()) : void 0;
-  const isCustomEndpoint = !!endpoint;
-  const resolvedConfig = Object.assign(input, {
-    endpoint: customEndpointProvider,
-    tls,
-    isCustomEndpoint,
-    useDualstackEndpoint: normalizeProvider(useDualstackEndpoint ?? false),
-    useFipsEndpoint: normalizeProvider(useFipsEndpoint ?? false)
-  });
-  let configuredEndpointPromise = void 0;
-  resolvedConfig.serviceConfiguredEndpoint = async () => {
-    if (input.serviceId && !configuredEndpointPromise) {
-      configuredEndpointPromise = getEndpointFromConfig(input.serviceId);
-    }
-    return configuredEndpointPromise;
-  };
-  return resolvedConfig;
-};
-
-// node_modules/@smithy/util-retry/dist-es/config.js
-var RETRY_MODES;
-(function(RETRY_MODES2) {
-  RETRY_MODES2["STANDARD"] = "standard";
-  RETRY_MODES2["ADAPTIVE"] = "adaptive";
-})(RETRY_MODES || (RETRY_MODES = {}));
-var DEFAULT_MAX_ATTEMPTS = 3;
-var DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
-
-// node_modules/@smithy/service-error-classification/dist-es/constants.js
-var THROTTLING_ERROR_CODES = [
-  "BandwidthLimitExceeded",
-  "EC2ThrottledException",
-  "LimitExceededException",
-  "PriorRequestNotComplete",
-  "ProvisionedThroughputExceededException",
-  "RequestLimitExceeded",
-  "RequestThrottled",
-  "RequestThrottledException",
-  "SlowDown",
-  "ThrottledException",
-  "Throttling",
-  "ThrottlingException",
-  "TooManyRequestsException",
-  "TransactionInProgressException"
-];
-var TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
-var TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
-var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
-var NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND"];
-
-// node_modules/@smithy/service-error-classification/dist-es/index.js
-var isRetryableByTrait = (error) => error?.$retryable !== void 0;
-var isClockSkewCorrectedError = (error) => error.$metadata?.clockSkewCorrected;
-var isBrowserNetworkError = (error) => {
-  const errorMessages = /* @__PURE__ */ new Set([
-    "Failed to fetch",
-    "NetworkError when attempting to fetch resource",
-    "The Internet connection appears to be offline",
-    "Load failed",
-    "Network request failed"
-  ]);
-  const isValid = error && error instanceof TypeError;
-  if (!isValid) {
-    return false;
-  }
-  return errorMessages.has(error.message);
-};
-var isThrottlingError = (error) => error.$metadata?.httpStatusCode === 429 || THROTTLING_ERROR_CODES.includes(error.name) || error.$retryable?.throttling == true;
-var isTransientError = (error, depth = 0) => isRetryableByTrait(error) || isClockSkewCorrectedError(error) || TRANSIENT_ERROR_CODES.includes(error.name) || NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") || NODEJS_NETWORK_ERROR_CODES.includes(error?.code || "") || TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) || isBrowserNetworkError(error) || error.cause !== void 0 && depth <= 10 && isTransientError(error.cause, depth + 1);
-var isServerError = (error) => {
-  if (error.$metadata?.httpStatusCode !== void 0) {
-    const statusCode = error.$metadata.httpStatusCode;
-    if (500 <= statusCode && statusCode <= 599 && !isTransientError(error)) {
-      return true;
-    }
-    return false;
-  }
-  return false;
-};
-
-// node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js
-var DefaultRateLimiter = class _DefaultRateLimiter {
-  static setTimeoutFn = setTimeout;
-  beta;
-  minCapacity;
-  minFillRate;
-  scaleConstant;
-  smooth;
-  currentCapacity = 0;
-  enabled = false;
-  lastMaxRate = 0;
-  measuredTxRate = 0;
-  requestCount = 0;
-  fillRate;
-  lastThrottleTime;
-  lastTimestamp = 0;
-  lastTxRateBucket;
-  maxCapacity;
-  timeWindow = 0;
-  constructor(options) {
-    this.beta = options?.beta ?? 0.7;
-    this.minCapacity = options?.minCapacity ?? 1;
-    this.minFillRate = options?.minFillRate ?? 0.5;
-    this.scaleConstant = options?.scaleConstant ?? 0.4;
-    this.smooth = options?.smooth ?? 0.8;
-    const currentTimeInSeconds = this.getCurrentTimeInSeconds();
-    this.lastThrottleTime = currentTimeInSeconds;
-    this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
-    this.fillRate = this.minFillRate;
-    this.maxCapacity = this.minCapacity;
-  }
-  getCurrentTimeInSeconds() {
-    return Date.now() / 1e3;
-  }
-  async getSendToken() {
-    return this.acquireTokenBucket(1);
-  }
-  async acquireTokenBucket(amount) {
-    if (!this.enabled) {
-      return;
-    }
-    this.refillTokenBucket();
-    if (amount > this.currentCapacity) {
-      const delay = (amount - this.currentCapacity) / this.fillRate * 1e3;
-      await new Promise((resolve) => _DefaultRateLimiter.setTimeoutFn(resolve, delay));
-    }
-    this.currentCapacity = this.currentCapacity - amount;
-  }
-  refillTokenBucket() {
-    const timestamp = this.getCurrentTimeInSeconds();
-    if (!this.lastTimestamp) {
-      this.lastTimestamp = timestamp;
-      return;
-    }
-    const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
-    this.currentCapacity = Math.min(this.maxCapacity, this.currentCapacity + fillAmount);
-    this.lastTimestamp = timestamp;
-  }
-  updateClientSendingRate(response) {
-    let calculatedRate;
-    this.updateMeasuredRate();
-    if (isThrottlingError(response)) {
-      const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
-      this.lastMaxRate = rateToUse;
-      this.calculateTimeWindow();
-      this.lastThrottleTime = this.getCurrentTimeInSeconds();
-      calculatedRate = this.cubicThrottle(rateToUse);
-      this.enableTokenBucket();
-    } else {
-      this.calculateTimeWindow();
-      calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds());
-    }
-    const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
-    this.updateTokenBucketRate(newRate);
-  }
-  calculateTimeWindow() {
-    this.timeWindow = this.getPrecise(Math.pow(this.lastMaxRate * (1 - this.beta) / this.scaleConstant, 1 / 3));
-  }
-  cubicThrottle(rateToUse) {
-    return this.getPrecise(rateToUse * this.beta);
-  }
-  cubicSuccess(timestamp) {
-    return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);
-  }
-  enableTokenBucket() {
-    this.enabled = true;
-  }
-  updateTokenBucketRate(newRate) {
-    this.refillTokenBucket();
-    this.fillRate = Math.max(newRate, this.minFillRate);
-    this.maxCapacity = Math.max(newRate, this.minCapacity);
-    this.currentCapacity = Math.min(this.currentCapacity, this.maxCapacity);
-  }
-  updateMeasuredRate() {
-    const t = this.getCurrentTimeInSeconds();
-    const timeBucket = Math.floor(t * 2) / 2;
-    this.requestCount++;
-    if (timeBucket > this.lastTxRateBucket) {
-      const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
-      this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));
-      this.requestCount = 0;
-      this.lastTxRateBucket = timeBucket;
-    }
-  }
-  getPrecise(num) {
-    return parseFloat(num.toFixed(8));
-  }
-};
-
-// node_modules/@smithy/util-retry/dist-es/constants.js
-var DEFAULT_RETRY_DELAY_BASE = 100;
-var MAXIMUM_RETRY_DELAY = 20 * 1e3;
-var THROTTLING_RETRY_DELAY_BASE = 500;
-var INITIAL_RETRY_TOKENS = 500;
-var RETRY_COST = 5;
-var TIMEOUT_RETRY_COST = 10;
-var NO_RETRY_INCREMENT = 1;
-var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
-var REQUEST_HEADER = "amz-sdk-request";
-
-// node_modules/@smithy/util-retry/dist-es/defaultRetryBackoffStrategy.js
-var getDefaultRetryBackoffStrategy = () => {
-  let delayBase = DEFAULT_RETRY_DELAY_BASE;
-  const computeNextBackoffDelay = (attempts) => {
-    return Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));
-  };
-  const setDelayBase = (delay) => {
-    delayBase = delay;
-  };
-  return {
-    computeNextBackoffDelay,
-    setDelayBase
-  };
-};
-
-// node_modules/@smithy/util-retry/dist-es/defaultRetryToken.js
-var createDefaultRetryToken = ({ retryDelay, retryCount, retryCost }) => {
-  const getRetryCount = () => retryCount;
-  const getRetryDelay = () => Math.min(MAXIMUM_RETRY_DELAY, retryDelay);
-  const getRetryCost = () => retryCost;
-  return {
-    getRetryCount,
-    getRetryDelay,
-    getRetryCost
-  };
-};
-
-// node_modules/@smithy/util-retry/dist-es/StandardRetryStrategy.js
-var StandardRetryStrategy = class {
-  maxAttempts;
-  mode = RETRY_MODES.STANDARD;
-  capacity = INITIAL_RETRY_TOKENS;
-  retryBackoffStrategy = getDefaultRetryBackoffStrategy();
-  maxAttemptsProvider;
-  constructor(maxAttempts) {
-    this.maxAttempts = maxAttempts;
-    this.maxAttemptsProvider = typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts;
-  }
-  async acquireInitialRetryToken(retryTokenScope) {
-    return createDefaultRetryToken({
-      retryDelay: DEFAULT_RETRY_DELAY_BASE,
-      retryCount: 0
-    });
-  }
-  async refreshRetryTokenForRetry(token, errorInfo) {
-    const maxAttempts = await this.getMaxAttempts();
-    if (this.shouldRetry(token, errorInfo, maxAttempts)) {
-      const errorType = errorInfo.errorType;
-      this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE);
-      const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
-      const retryDelay = errorInfo.retryAfterHint ? Math.max(errorInfo.retryAfterHint.getTime() - Date.now() || 0, delayFromErrorType) : delayFromErrorType;
-      const capacityCost = this.getCapacityCost(errorType);
-      this.capacity -= capacityCost;
-      return createDefaultRetryToken({
-        retryDelay,
-        retryCount: token.getRetryCount() + 1,
-        retryCost: capacityCost
-      });
-    }
-    throw new Error("No retry token available");
-  }
-  recordSuccess(token) {
-    this.capacity = Math.max(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
-  }
-  getCapacity() {
-    return this.capacity;
-  }
-  async getMaxAttempts() {
-    try {
-      return await this.maxAttemptsProvider();
-    } catch (error) {
-      console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);
-      return DEFAULT_MAX_ATTEMPTS;
-    }
-  }
-  shouldRetry(tokenToRenew, errorInfo, maxAttempts) {
-    const attempts = tokenToRenew.getRetryCount() + 1;
-    return attempts < maxAttempts && this.capacity >= this.getCapacityCost(errorInfo.errorType) && this.isRetryableError(errorInfo.errorType);
-  }
-  getCapacityCost(errorType) {
-    return errorType === "TRANSIENT" ? TIMEOUT_RETRY_COST : RETRY_COST;
-  }
-  isRetryableError(errorType) {
-    return errorType === "THROTTLING" || errorType === "TRANSIENT";
-  }
-};
-
-// node_modules/@smithy/util-retry/dist-es/AdaptiveRetryStrategy.js
-var AdaptiveRetryStrategy = class {
-  maxAttemptsProvider;
-  rateLimiter;
-  standardRetryStrategy;
-  mode = RETRY_MODES.ADAPTIVE;
-  constructor(maxAttemptsProvider, options) {
-    this.maxAttemptsProvider = maxAttemptsProvider;
-    const { rateLimiter } = options ?? {};
-    this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
-    this.standardRetryStrategy = new StandardRetryStrategy(maxAttemptsProvider);
-  }
-  async acquireInitialRetryToken(retryTokenScope) {
-    await this.rateLimiter.getSendToken();
-    return this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
-  }
-  async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
-    this.rateLimiter.updateClientSendingRate(errorInfo);
-    return this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
-  }
-  recordSuccess(token) {
-    this.rateLimiter.updateClientSendingRate({});
-    this.standardRetryStrategy.recordSuccess(token);
-  }
-};
-
-// node_modules/@smithy/middleware-retry/dist-es/configurations.js
-var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
-var CONFIG_MAX_ATTEMPTS = "max_attempts";
-var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => {
-    const value = env2[ENV_MAX_ATTEMPTS];
-    if (!value)
-      return void 0;
-    const maxAttempt = parseInt(value);
-    if (Number.isNaN(maxAttempt)) {
-      throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
-    }
-    return maxAttempt;
-  },
-  configFileSelector: (profile) => {
-    const value = profile[CONFIG_MAX_ATTEMPTS];
-    if (!value)
-      return void 0;
-    const maxAttempt = parseInt(value);
-    if (Number.isNaN(maxAttempt)) {
-      throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
-    }
-    return maxAttempt;
-  },
-  default: DEFAULT_MAX_ATTEMPTS
-};
-var resolveRetryConfig = (input) => {
-  const { retryStrategy, retryMode: _retryMode, maxAttempts: _maxAttempts } = input;
-  const maxAttempts = normalizeProvider(_maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
-  return Object.assign(input, {
-    maxAttempts,
-    retryStrategy: async () => {
-      if (retryStrategy) {
-        return retryStrategy;
-      }
-      const retryMode = await normalizeProvider(_retryMode)();
-      if (retryMode === RETRY_MODES.ADAPTIVE) {
-        return new AdaptiveRetryStrategy(maxAttempts);
-      }
-      return new StandardRetryStrategy(maxAttempts);
-    }
-  });
-};
-var ENV_RETRY_MODE = "AWS_RETRY_MODE";
-var CONFIG_RETRY_MODE = "retry_mode";
-var NODE_RETRY_MODE_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => env2[ENV_RETRY_MODE],
-  configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
-  default: DEFAULT_RETRY_MODE
-};
-
-// node_modules/@smithy/middleware-retry/dist-es/isStreamingPayload/isStreamingPayload.js
-import { Readable } from "stream";
-var isStreamingPayload = (request) => request?.body instanceof Readable || typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream;
-
-// node_modules/@smithy/middleware-retry/dist-es/util.js
-var asSdkError = (error) => {
-  if (error instanceof Error)
-    return error;
-  if (error instanceof Object)
-    return Object.assign(new Error(), error);
-  if (typeof error === "string")
-    return new Error(error);
-  return new Error(`AWS SDK error wrapper for ${error}`);
-};
-
-// node_modules/@smithy/middleware-retry/dist-es/retryMiddleware.js
-var retryMiddleware = (options) => (next, context) => async (args) => {
-  let retryStrategy = await options.retryStrategy();
-  const maxAttempts = await options.maxAttempts();
-  if (isRetryStrategyV2(retryStrategy)) {
-    retryStrategy = retryStrategy;
-    let retryToken = await retryStrategy.acquireInitialRetryToken(context["partition_id"]);
-    let lastError = new Error();
-    let attempts = 0;
-    let totalRetryDelay = 0;
-    const { request } = args;
-    const isRequest = HttpRequest.isInstance(request);
-    if (isRequest) {
-      request.headers[INVOCATION_ID_HEADER] = v4();
-    }
-    while (true) {
-      try {
-        if (isRequest) {
-          request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
-        }
-        const { response, output } = await next(args);
-        retryStrategy.recordSuccess(retryToken);
-        output.$metadata.attempts = attempts + 1;
-        output.$metadata.totalRetryDelay = totalRetryDelay;
-        return { response, output };
-      } catch (e) {
-        const retryErrorInfo = getRetryErrorInfo(e);
-        lastError = asSdkError(e);
-        if (isRequest && isStreamingPayload(request)) {
-          (context.logger instanceof NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
-          throw lastError;
-        }
-        try {
-          retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
-        } catch (refreshError) {
-          if (!lastError.$metadata) {
-            lastError.$metadata = {};
-          }
-          lastError.$metadata.attempts = attempts + 1;
-          lastError.$metadata.totalRetryDelay = totalRetryDelay;
-          throw lastError;
-        }
-        attempts = retryToken.getRetryCount();
-        const delay = retryToken.getRetryDelay();
-        totalRetryDelay += delay;
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-  } else {
-    retryStrategy = retryStrategy;
-    if (retryStrategy?.mode)
-      context.userAgent = [...context.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]];
-    return retryStrategy.retry(next, args);
-  }
-};
-var isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && typeof retryStrategy.recordSuccess !== "undefined";
-var getRetryErrorInfo = (error) => {
-  const errorInfo = {
-    error,
-    errorType: getRetryErrorType(error)
-  };
-  const retryAfterHint = getRetryAfterHint(error.$response);
-  if (retryAfterHint) {
-    errorInfo.retryAfterHint = retryAfterHint;
-  }
-  return errorInfo;
-};
-var getRetryErrorType = (error) => {
-  if (isThrottlingError(error))
-    return "THROTTLING";
-  if (isTransientError(error))
-    return "TRANSIENT";
-  if (isServerError(error))
-    return "SERVER_ERROR";
-  return "CLIENT_ERROR";
-};
-var retryMiddlewareOptions = {
-  name: "retryMiddleware",
-  tags: ["RETRY"],
-  step: "finalizeRequest",
-  priority: "high",
-  override: true
-};
-var getRetryPlugin = (options) => ({
-  applyToStack: (clientStack) => {
-    clientStack.add(retryMiddleware(options), retryMiddlewareOptions);
-  }
-});
-var getRetryAfterHint = (response) => {
-  if (!HttpResponse.isInstance(response))
-    return;
-  const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
-  if (!retryAfterHeaderName)
-    return;
-  const retryAfter = response.headers[retryAfterHeaderName];
-  const retryAfterSeconds = Number(retryAfter);
-  if (!Number.isNaN(retryAfterSeconds))
-    return new Date(retryAfterSeconds * 1e3);
-  const retryAfterDate = new Date(retryAfter);
-  return retryAfterDate;
-};
-
-// node_modules/@smithy/util-config-provider/dist-es/booleanSelector.js
-var booleanSelector = (obj, key, type) => {
-  if (!(key in obj))
-    return void 0;
-  if (obj[key] === "true")
-    return true;
-  if (obj[key] === "false")
-    return false;
-  throw new Error(`Cannot load ${type} "${key}". Expected "true" or "false", got ${obj[key]}.`);
-};
-
-// node_modules/@smithy/util-config-provider/dist-es/types.js
-var SelectorType;
-(function(SelectorType2) {
-  SelectorType2["ENV"] = "env";
-  SelectorType2["CONFIG"] = "shared config entry";
-})(SelectorType || (SelectorType = {}));
-
-// node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseDualstackEndpointConfigOptions.js
-var ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
-var CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
-var NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => booleanSelector(env2, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
-  configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
-  default: false
-};
-
-// node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseFipsEndpointConfigOptions.js
-var ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT";
-var CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint";
-var NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => booleanSelector(env2, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
-  configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
-  default: false
-};
-
-// node_modules/@smithy/config-resolver/dist-es/regionConfig/config.js
-var REGION_ENV_NAME = "AWS_REGION";
-var REGION_INI_NAME = "region";
-var NODE_REGION_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => env2[REGION_ENV_NAME],
-  configFileSelector: (profile) => profile[REGION_INI_NAME],
-  default: () => {
-    throw new Error("Region is missing");
-  }
-};
-var NODE_REGION_CONFIG_FILE_OPTIONS = {
-  preferredFile: "credentials"
-};
-
-// node_modules/@aws-sdk/util-user-agent-node/dist-es/defaultUserAgent.js
-import { platform, release } from "os";
-import { env, versions } from "process";
-
-// node_modules/@aws-sdk/util-user-agent-node/dist-es/crt-availability.js
-var crtAvailability = {
-  isCrtAvailable: false
-};
-
-// node_modules/@aws-sdk/util-user-agent-node/dist-es/is-crt-available.js
-var isCrtAvailable = () => {
-  if (crtAvailability.isCrtAvailable) {
-    return ["md/crt-avail"];
-  }
-  return null;
-};
-
-// node_modules/@aws-sdk/util-user-agent-node/dist-es/defaultUserAgent.js
-var createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
-  return async (config) => {
-    const sections = [
-      ["aws-sdk-js", clientVersion],
-      ["ua", "2.1"],
-      [`os/${platform()}`, release()],
-      ["lang/js"],
-      ["md/nodejs", `${versions.node}`]
-    ];
-    const crtAvailable = isCrtAvailable();
-    if (crtAvailable) {
-      sections.push(crtAvailable);
-    }
-    if (serviceId) {
-      sections.push([`api/${serviceId}`, clientVersion]);
-    }
-    if (env.AWS_EXECUTION_ENV) {
-      sections.push([`exec-env/${env.AWS_EXECUTION_ENV}`]);
-    }
-    const appId = await config?.userAgentAppId?.();
-    const resolvedUserAgent = appId ? [...sections, [`app/${appId}`]] : [...sections];
-    return resolvedUserAgent;
-  };
-};
-
-// node_modules/@aws-sdk/util-user-agent-node/dist-es/nodeAppIdConfigOptions.js
-var UA_APP_ID_ENV_NAME = "AWS_SDK_UA_APP_ID";
-var UA_APP_ID_INI_NAME = "sdk_ua_app_id";
-var UA_APP_ID_INI_NAME_DEPRECATED = "sdk-ua-app-id";
-var NODE_APP_ID_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => env2[UA_APP_ID_ENV_NAME],
-  configFileSelector: (profile) => profile[UA_APP_ID_INI_NAME] ?? profile[UA_APP_ID_INI_NAME_DEPRECATED],
-  default: DEFAULT_UA_APP_ID
-};
-
-// node_modules/@smithy/hash-node/dist-es/index.js
-import { Buffer as Buffer2 } from "buffer";
-import { createHash, createHmac } from "crypto";
-var Hash = class {
-  algorithmIdentifier;
-  secret;
-  hash;
-  constructor(algorithmIdentifier, secret) {
-    this.algorithmIdentifier = algorithmIdentifier;
-    this.secret = secret;
-    this.reset();
-  }
-  update(toHash, encoding) {
-    this.hash.update(toUint8Array(castSourceData(toHash, encoding)));
-  }
-  digest() {
-    return Promise.resolve(this.hash.digest());
-  }
-  reset() {
-    this.hash = this.secret ? createHmac(this.algorithmIdentifier, castSourceData(this.secret)) : createHash(this.algorithmIdentifier);
-  }
-};
-function castSourceData(toCast, encoding) {
-  if (Buffer2.isBuffer(toCast)) {
-    return toCast;
-  }
-  if (typeof toCast === "string") {
-    return fromString(toCast, encoding);
-  }
-  if (ArrayBuffer.isView(toCast)) {
-    return fromArrayBuffer(toCast.buffer, toCast.byteOffset, toCast.byteLength);
-  }
-  return fromArrayBuffer(toCast);
-}
-
-// node_modules/@smithy/util-body-length-node/dist-es/calculateBodyLength.js
-import { fstatSync, lstatSync, ReadStream } from "node:fs";
-var calculateBodyLength = (body) => {
-  if (!body) {
-    return 0;
-  }
-  if (typeof body === "string") {
-    return Buffer.byteLength(body);
-  } else if (typeof body.byteLength === "number") {
-    return body.byteLength;
-  } else if (typeof body.size === "number") {
-    return body.size;
-  } else if (typeof body.start === "number" && typeof body.end === "number") {
-    return body.end + 1 - body.start;
-  } else if (body instanceof ReadStream) {
-    if (body.path != null) {
-      return lstatSync(body.path).size;
-    } else if (typeof body.fd === "number") {
-      return fstatSync(body.fd).size;
-    }
-  }
-  throw new Error(`Body Length computation failed for ${body}`);
-};
-
-// node_modules/@smithy/util-defaults-mode-node/dist-es/constants.js
-var AWS_EXECUTION_ENV = "AWS_EXECUTION_ENV";
-var AWS_REGION_ENV = "AWS_REGION";
-var AWS_DEFAULT_REGION_ENV = "AWS_DEFAULT_REGION";
-var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
-var DEFAULTS_MODE_OPTIONS = ["in-region", "cross-region", "mobile", "standard", "legacy"];
-var IMDS_REGION_PATH = "/latest/meta-data/placement/region";
-
-// node_modules/@smithy/util-defaults-mode-node/dist-es/defaultsModeConfig.js
-var AWS_DEFAULTS_MODE_ENV = "AWS_DEFAULTS_MODE";
-var AWS_DEFAULTS_MODE_CONFIG = "defaults_mode";
-var NODE_DEFAULTS_MODE_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => {
-    return env2[AWS_DEFAULTS_MODE_ENV];
-  },
-  configFileSelector: (profile) => {
-    return profile[AWS_DEFAULTS_MODE_CONFIG];
-  },
-  default: "legacy"
-};
-
-// node_modules/@smithy/util-defaults-mode-node/dist-es/resolveDefaultsModeConfig.js
-var resolveDefaultsModeConfig = ({ region = loadConfig(NODE_REGION_CONFIG_OPTIONS), defaultsMode = loadConfig(NODE_DEFAULTS_MODE_CONFIG_OPTIONS) } = {}) => memoize(async () => {
-  const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode;
-  switch (mode?.toLowerCase()) {
-    case "auto":
-      return resolveNodeDefaultsModeAuto(region);
-    case "in-region":
-    case "cross-region":
-    case "mobile":
-    case "standard":
-    case "legacy":
-      return Promise.resolve(mode?.toLocaleLowerCase());
-    case void 0:
-      return Promise.resolve("legacy");
-    default:
-      throw new Error(`Invalid parameter for "defaultsMode", expect ${DEFAULTS_MODE_OPTIONS.join(", ")}, got ${mode}`);
-  }
-});
-var resolveNodeDefaultsModeAuto = async (clientRegion) => {
-  if (clientRegion) {
-    const resolvedRegion = typeof clientRegion === "function" ? await clientRegion() : clientRegion;
-    const inferredRegion = await inferPhysicalRegion();
-    if (!inferredRegion) {
-      return "standard";
-    }
-    if (resolvedRegion === inferredRegion) {
-      return "in-region";
-    } else {
-      return "cross-region";
-    }
-  }
-  return "standard";
-};
-var inferPhysicalRegion = async () => {
-  if (process.env[AWS_EXECUTION_ENV] && (process.env[AWS_REGION_ENV] || process.env[AWS_DEFAULT_REGION_ENV])) {
-    return process.env[AWS_REGION_ENV] ?? process.env[AWS_DEFAULT_REGION_ENV];
-  }
-  if (!process.env[ENV_IMDS_DISABLED]) {
-    try {
-      const { getInstanceMetadataEndpoint, httpRequest } = await import("./dist-es-O7YXE2TO.js");
-      const endpoint = await getInstanceMetadataEndpoint();
-      return (await httpRequest({ ...endpoint, path: IMDS_REGION_PATH })).toString();
-    } catch (e) {
-    }
-  }
-};
-
-// node_modules/@aws-sdk/region-config-resolver/dist-es/extensions/index.js
-var getAwsRegionExtensionConfiguration = (runtimeConfig) => {
-  return {
-    setRegion(region) {
-      runtimeConfig.region = region;
-    },
-    region() {
-      return runtimeConfig.region;
-    }
-  };
-};
-var resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) => {
-  return {
-    region: awsRegionExtensionConfiguration.region()
-  };
-};
-
-export {
-  getHttpHandlerExtensionConfiguration,
-  resolveHttpHandlerRuntimeConfig,
-  resolveHostHeaderConfig,
-  getHostHeaderPlugin,
-  getLoggerPlugin,
-  getRecursionDetectionPlugin,
-  Client,
-  toUint8Array,
-  collectBody,
-  extendedEncodeURIComponent,
-  getSmithyContext,
-  normalizeProvider,
-  Command,
-  SENSITIVE_STRING2 as SENSITIVE_STRING,
-  ServiceException,
-  decorateServiceException,
-  withBaseException,
-  loadConfigsForDefaultMode,
-  emitWarningIfUnsupportedVersion2 as emitWarningIfUnsupportedVersion,
-  getDefaultExtensionConfiguration,
-  resolveDefaultRuntimeConfig,
-  NoOpLogger,
-  getHttpAuthSchemeEndpointRuleSetPlugin,
-  getSerdePlugin,
-  httpSigningMiddlewareOptions,
-  getHttpSigningPlugin,
-  DefaultIdentityProviderConfig,
-  resolveUserAgentConfig,
-  EndpointCache,
-  customEndpointFunctions,
-  resolveEndpoint,
-  awsEndpointFunctions,
-  emitWarningIfUnsupportedVersion as emitWarningIfUnsupportedVersion2,
-  setFeature2 as setFeature,
-  AwsSdkSigV4Signer,
-  AwsSdkSigV4ASigner,
-  NODE_AUTH_SCHEME_PREFERENCE_OPTIONS,
-  resolveAwsSdkSigV4AConfig,
-  NODE_SIGV4A_CONFIG_OPTIONS,
-  SignatureV4,
-  resolveAwsSdkSigV4Config,
-  collectBodyString,
-  getUserAgentPlugin,
-  booleanSelector,
-  SelectorType,
-  NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS,
-  NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS,
-  NODE_REGION_CONFIG_OPTIONS,
-  NODE_REGION_CONFIG_FILE_OPTIONS,
-  resolveRegionConfig,
-  getContentLengthPlugin,
-  resolveParams,
-  getEndpointPlugin,
-  resolveEndpointConfig,
-  DEFAULT_RETRY_MODE,
-  NODE_MAX_ATTEMPT_CONFIG_OPTIONS,
-  resolveRetryConfig,
-  NODE_RETRY_MODE_CONFIG_OPTIONS,
-  getRetryPlugin,
-  createDefaultUserAgentProvider,
-  NODE_APP_ID_CONFIG_OPTIONS,
-  Hash,
-  calculateBodyLength,
-  resolveDefaultsModeConfig,
-  getAwsRegionExtensionConfiguration,
-  resolveAwsRegionExtensionConfiguration
-};
-//# sourceMappingURL=chunk-4QSQRVYQ.js.map