@semiont/graph 0.5.4 → 0.5.6

package/dist/chunk-7UD62TQI.js

@@ -0,0 +1,3317 @@
+import {
+  CONFIG_PREFIX_SEPARATOR,
+  HttpRequest,
+  HttpResponse,
+  NODE_REGION_CONFIG_FILE_OPTIONS,
+  NODE_REGION_CONFIG_OPTIONS,
+  NormalizedSchema,
+  SMITHY_CONTEXT_KEY,
+  SelectorType,
+  booleanSelector,
+  getSmithyContext,
+  isValidHostLabel,
+  loadConfig,
+  normalizeProvider,
+  toEndpointV1
+} from "./chunk-4UP2SG3N.js";
+import {
+  parseRfc7231DateTime,
+  v4
+} from "./chunk-DCLCNCC5.js";
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/middleware-stack/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/core/dist-es/submodules/client/smithy-client/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/core/dist-es/submodules/client/smithy-client/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 [member, memberNs] of ns.structIterator()) {
+      if (object[member] != null) {
+        newObject[member] = schemaLogFilter(memberNs, object[member]);
+      }
+    }
+    return newObject;
+  }
+  return data;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/smithy-client/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;
+    let requestOptions = options ?? {};
+    if (smithyContext.eventStream) {
+      requestOptions = {
+        isEventStream: true,
+        ...requestOptions
+      };
+    }
+    return stack.resolve((request) => requestHandler.handle(request.request, requestOptions), 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/@smithy/core/dist-es/submodules/client/util-waiter/circularReplacer.js
+var getCircularReplacer = () => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/util-waiter/utils/sleep.js
+var sleep = (seconds) => {
+  return new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/util-waiter/waiter.js
+var waiterServiceDefaults = {
+  minDelay: 2,
+  maxDelay: 120
+};
+var WaiterState;
+(function(WaiterState2) {
+  WaiterState2["ABORTED"] = "ABORTED";
+  WaiterState2["FAILURE"] = "FAILURE";
+  WaiterState2["SUCCESS"] = "SUCCESS";
+  WaiterState2["RETRY"] = "RETRY";
+  WaiterState2["TIMEOUT"] = "TIMEOUT";
+})(WaiterState || (WaiterState = {}));
+var checkExceptions = (result) => {
+  if (result.state === WaiterState.ABORTED) {
+    const abortError = new Error(`${JSON.stringify({
+      ...result,
+      reason: "Request was aborted"
+    }, getCircularReplacer())}`);
+    abortError.name = "AbortError";
+    throw abortError;
+  } else if (result.state === WaiterState.TIMEOUT) {
+    const timeoutError = new Error(`${JSON.stringify({
+      ...result,
+      reason: "Waiter has timed out"
+    }, getCircularReplacer())}`);
+    timeoutError.name = "TimeoutError";
+    throw timeoutError;
+  } else if (result.state !== WaiterState.SUCCESS) {
+    throw new Error(`${JSON.stringify(result, getCircularReplacer())}`);
+  }
+  return result;
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/util-waiter/poller.js
+var runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }, input, acceptorChecks) => {
+  const observedResponses = {};
+  const [minDelayMs, maxDelayMs] = [minDelay * 1e3, maxDelay * 1e3];
+  let currentAttempt = 0;
+  const waitUntil = Date.now() + maxWaitTime * 1e3;
+  const warn403Time = Date.now() + 6e4;
+  let didWarn403 = false;
+  while (true) {
+    if (currentAttempt > 0) {
+      const delayMs = exponentialBackoffWithJitter(minDelayMs, maxDelayMs, currentAttempt, waitUntil);
+      if (abortController?.signal?.aborted || abortSignal?.aborted) {
+        const message = "AbortController signal aborted.";
+        observedResponses[message] |= 0;
+        observedResponses[message] += 1;
+        return { state: WaiterState.ABORTED, observedResponses };
+      }
+      if (Date.now() + delayMs > waitUntil) {
+        return { state: WaiterState.TIMEOUT, observedResponses };
+      }
+      await sleep(delayMs / 1e3);
+    }
+    const { state: state2, reason } = await acceptorChecks(client, input);
+    if (reason) {
+      const message = createMessageFromResponse(reason);
+      observedResponses[message] |= 0;
+      observedResponses[message] += 1;
+    }
+    if (state2 !== WaiterState.RETRY) {
+      return { state: state2, reason, final: reason, observedResponses };
+    }
+    currentAttempt += 1;
+    if (!didWarn403 && Date.now() >= warn403Time) {
+      checkWarn403(observedResponses, client);
+      didWarn403 = true;
+    }
+  }
+};
+var checkWarn403 = (observedResponses = {}, client) => {
+  const orderedErrors = Object.keys(observedResponses);
+  let maxCount = 0;
+  let count403 = 0;
+  for (const response of orderedErrors) {
+    const n = observedResponses[response] | 0;
+    maxCount = Math.max(n, maxCount);
+    if (response.startsWith("403:")) {
+      count403 += n;
+    }
+  }
+  const clientLogger = client?.config?.logger;
+  const warningLogger = typeof clientLogger?.warn === "function" && !clientLogger.constructor?.name?.includes?.("NoOpLogger") ? clientLogger : console;
+  if (count403 >= 3 || orderedErrors[orderedErrors.length - 1]?.startsWith("403:")) {
+    warningLogger.warn(`@smithy/util-waiter WARN - 403 status code encountered during waiter polling.`);
+  }
+};
+var createMessageFromResponse = (reason) => {
+  const status = reason?.$response?.statusCode ?? reason?.$metadata?.httpStatusCode;
+  if (reason?.$responseBodyText) {
+    return `${status ? status + ": " : ""}Deserialization error for body: ${reason.$responseBodyText}`;
+  }
+  if (status) {
+    if (reason?.$response || reason?.message) {
+      return `${status ?? "Unknown"}: ${reason?.message}`;
+    }
+    return `${status}: OK`;
+  }
+  return String(reason?.message ?? JSON.stringify(reason, getCircularReplacer()) ?? "Unknown");
+};
+var exponentialBackoffWithJitter = (minDelayMs, maxDelayMs, attempt, waitUntil) => {
+  const attemptCountCeiling = Math.log(maxDelayMs / minDelayMs) / Math.log(2) + 1;
+  if (attempt > attemptCountCeiling) {
+    return maxDelayMs;
+  }
+  const delay = minDelayMs * 2 ** (attempt - 1);
+  const capped = Math.min(delay, maxDelayMs);
+  const waitFor = randomInRange(minDelayMs, capped);
+  if (Date.now() + waitFor > waitUntil) {
+    const timeRemaining = waitUntil - Date.now();
+    return Math.max(0, timeRemaining - 500);
+  }
+  return waitFor;
+};
+var randomInRange = (min, max) => min + Math.random() * (max - min);
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/util-waiter/utils/validate.js
+var validateWaiterOptions = (options) => {
+  if (options.maxWaitTime <= 0) {
+    throw new Error(`WaiterConfiguration.maxWaitTime must be greater than 0`);
+  } else if (options.minDelay <= 0) {
+    throw new Error(`WaiterConfiguration.minDelay must be greater than 0`);
+  } else if (options.maxDelay <= 0) {
+    throw new Error(`WaiterConfiguration.maxDelay must be greater than 0`);
+  } else if (options.maxWaitTime <= options.minDelay) {
+    throw new Error(`WaiterConfiguration.maxWaitTime [${options.maxWaitTime}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
+  } else if (options.maxDelay < options.minDelay) {
+    throw new Error(`WaiterConfiguration.maxDelay [${options.maxDelay}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/util-waiter/createWaiter.js
+var abortTimeout = (abortSignal) => {
+  let onAbort;
+  const promise = new Promise((resolve) => {
+    onAbort = () => resolve({ state: WaiterState.ABORTED });
+    if (typeof abortSignal.addEventListener === "function") {
+      abortSignal.addEventListener("abort", onAbort);
+    } else {
+      abortSignal.onabort = onAbort;
+    }
+  });
+  return {
+    clearListener() {
+      if (typeof abortSignal.removeEventListener === "function") {
+        abortSignal.removeEventListener("abort", onAbort);
+      }
+    },
+    aborted: promise
+  };
+};
+var createWaiter = async (options, input, acceptorChecks) => {
+  const params = {
+    ...waiterServiceDefaults,
+    ...options
+  };
+  validateWaiterOptions(params);
+  const exitConditions = [runPolling(params, input, acceptorChecks)];
+  const finalize = [];
+  if (options.abortSignal) {
+    const { aborted, clearListener } = abortTimeout(options.abortSignal);
+    finalize.push(clearListener);
+    exitConditions.push(aborted);
+  }
+  if (options.abortController?.signal) {
+    const { aborted, clearListener } = abortTimeout(options.abortController.signal);
+    finalize.push(clearListener);
+    exitConditions.push(aborted);
+  }
+  return Promise.race(exitConditions).then((result) => {
+    for (const fn of finalize) {
+      fn();
+    }
+    return result;
+  });
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/smithy-client/create-aggregated-client.js
+var createAggregatedClient = (commands, Client2, options) => {
+  for (const [command, CommandCtor] of Object.entries(commands)) {
+    const methodImpl = async function(args, optionsOrCb, cb) {
+      const command2 = new CommandCtor(args);
+      if (typeof optionsOrCb === "function") {
+        this.send(command2, optionsOrCb);
+      } else if (typeof cb === "function") {
+        if (typeof optionsOrCb !== "object")
+          throw new Error(`Expected http options but got ${typeof optionsOrCb}`);
+        this.send(command2, optionsOrCb || {}, cb);
+      } else {
+        return this.send(command2, optionsOrCb);
+      }
+    };
+    const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
+    Client2.prototype[methodName] = methodImpl;
+  }
+  const { paginators = {}, waiters = {} } = options ?? {};
+  for (const [paginatorName, paginatorFn] of Object.entries(paginators)) {
+    if (Client2.prototype[paginatorName] === void 0) {
+      Client2.prototype[paginatorName] = function(commandInput = {}, paginationConfiguration, ...rest) {
+        return paginatorFn({
+          ...paginationConfiguration,
+          client: this
+        }, commandInput, ...rest);
+      };
+    }
+  }
+  for (const [waiterName, waiterFn] of Object.entries(waiters)) {
+    if (Client2.prototype[waiterName] === void 0) {
+      Client2.prototype[waiterName] = async function(commandInput = {}, waiterConfiguration, ...rest) {
+        let config = waiterConfiguration;
+        if (typeof waiterConfiguration === "number") {
+          config = {
+            maxWaitTime: waiterConfiguration
+          };
+        }
+        return waiterFn({
+          ...config,
+          client: this
+        }, commandInput, ...rest);
+      };
+    }
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/smithy-client/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/submodules/client/smithy-client/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/core/dist-es/submodules/client/smithy-client/emitWarningIfUnsupportedVersion.js
+var warningEmitted = false;
+var emitWarningIfUnsupportedVersion = (version) => {
+  if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
+    warningEmitted = true;
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/smithy-client/extensions/checksum.js
+var knownAlgorithms = Object.values(AlgorithmId);
+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]
+    });
+  }
+  for (const [id, ChecksumCtor] of Object.entries(runtimeConfig.checksumAlgorithms ?? {})) {
+    checksumAlgorithms.push({
+      algorithmId: () => id,
+      checksumConstructor: () => ChecksumCtor
+    });
+  }
+  return {
+    addChecksumAlgorithm(algo) {
+      runtimeConfig.checksumAlgorithms = runtimeConfig.checksumAlgorithms ?? {};
+      const id = algo.algorithmId();
+      const ctor = algo.checksumConstructor();
+      if (knownAlgorithms.includes(id)) {
+        runtimeConfig.checksumAlgorithms[id.toUpperCase()] = ctor;
+      } else {
+        runtimeConfig.checksumAlgorithms[id] = ctor;
+      }
+      checksumAlgorithms.push(algo);
+    },
+    checksumAlgorithms() {
+      return checksumAlgorithms;
+    }
+  };
+};
+var resolveChecksumRuntimeConfig = (clientConfig) => {
+  const runtimeConfig = {};
+  clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
+    const id = checksumAlgorithm.algorithmId();
+    if (knownAlgorithms.includes(id)) {
+      runtimeConfig[id] = checksumAlgorithm.checksumConstructor();
+    }
+  });
+  return runtimeConfig;
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/smithy-client/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/core/dist-es/submodules/client/smithy-client/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/core/dist-es/submodules/client/smithy-client/get-value-from-text-node.js
+var getValueFromTextNode = (obj) => {
+  const textNodeName = "#text";
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== void 0) {
+      obj[key] = obj[key][textNodeName];
+    } else if (typeof obj[key] === "object" && obj[key] !== null) {
+      obj[key] = getValueFromTextNode(obj[key]);
+    }
+  }
+  return obj;
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/client/smithy-client/NoOpLogger.js
+var NoOpLogger = class {
+  trace() {
+  }
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/setCredentialFeature.js
+function setCredentialFeature(credentials, feature, value) {
+  if (!credentials.$source) {
+    credentials.$source = {};
+  }
+  credentials.$source[feature] = value;
+  return credentials;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/middleware-endpoint/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/core/dist-es/submodules/endpoints/middleware-endpoint/adaptors/getEndpointFromConfig.js
+var getEndpointFromConfig = async (serviceId) => loadConfig(getEndpointUrlConfig(serviceId ?? ""))();
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/middleware-endpoint/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/core/dist-es/submodules/endpoints/middleware-endpoint/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/core/dist-es/submodules/endpoints/middleware-endpoint/adaptors/getEndpointFromInstructions.js
+function bindGetEndpointFromInstructions(getEndpointFromConfig2) {
+  return async (commandInput, instructionsSupplier, clientConfig, context) => {
+    if (!clientConfig.isCustomEndpoint) {
+      let endpointFromConfig;
+      if (clientConfig.serviceConfiguredEndpoint) {
+        endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
+      } else {
+        endpointFromConfig = await getEndpointFromConfig2(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);
+    if (clientConfig.isCustomEndpoint && clientConfig.endpoint) {
+      const customEndpoint = await clientConfig.endpoint();
+      if (customEndpoint?.headers) {
+        endpoint.headers ??= {};
+        for (const [name, value] of Object.entries(customEndpoint.headers)) {
+          endpoint.headers[name] = Array.isArray(value) ? value : [value];
+        }
+      }
+    }
+    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/core/dist-es/submodules/endpoints/middleware-endpoint/endpointMiddleware.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;
+}
+function bindEndpointMiddleware(getEndpointFromConfig2) {
+  const getEndpointFromInstructions2 = bindGetEndpointFromInstructions(getEndpointFromConfig2);
+  return ({ config, instructions }) => {
+    return (next, context) => async (args) => {
+      if (config.isCustomEndpoint) {
+        setFeature(context, "ENDPOINT_OVERRIDE", "N");
+      }
+      const endpoint = await getEndpointFromInstructions2(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/core/dist-es/submodules/endpoints/middleware-endpoint/getEndpointPlugin.js
+var serializerMiddlewareOption = {
+  name: "serializerMiddleware",
+  step: "serialize",
+  tags: ["SERIALIZER"],
+  override: true
+};
+var endpointMiddlewareOptions = {
+  step: "serialize",
+  tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
+  name: "endpointV2Middleware",
+  override: true,
+  relation: "before",
+  toMiddleware: serializerMiddlewareOption.name
+};
+function bindGetEndpointPlugin(getEndpointFromConfig2) {
+  const endpointMiddleware2 = bindEndpointMiddleware(getEndpointFromConfig2);
+  return (config, instructions) => ({
+    applyToStack: (clientStack) => {
+      clientStack.addRelativeTo(endpointMiddleware2({
+        config,
+        instructions
+      }), endpointMiddlewareOptions);
+    }
+  });
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/middleware-endpoint/resolveEndpointConfig.js
+function bindResolveEndpointConfig(getEndpointFromConfig2) {
+  return (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 = getEndpointFromConfig2(input.serviceId);
+      }
+      return configuredEndpointPromise;
+    };
+    return resolvedConfig;
+  };
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/bdd/BinaryDecisionDiagram.js
+var BinaryDecisionDiagram = class _BinaryDecisionDiagram {
+  nodes;
+  root;
+  conditions;
+  results;
+  constructor(bdd, root, conditions, results) {
+    this.nodes = bdd;
+    this.root = root;
+    this.conditions = conditions;
+    this.results = results;
+  }
+  static from(bdd, root, conditions, results) {
+    return new _BinaryDecisionDiagram(bdd, root, conditions, results);
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/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/core/dist-es/submodules/endpoints/util-endpoints/types/EndpointError.js
+var EndpointError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EndpointError";
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/debug/debugId.js
+var debugId = "endpoints";
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/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/core/dist-es/submodules/endpoints/util-endpoints/utils/customEndpointFunctions.js
+var customEndpointFunctions = {};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/booleanEquals.js
+var booleanEquals = (value1, value2) => value1 === value2;
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/coalesce.js
+function coalesce(...args) {
+  for (const arg of args) {
+    if (arg != null) {
+      return arg;
+    }
+  }
+  return void 0;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/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/core/dist-es/submodules/endpoints/util-endpoints/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)) {
+    const i = parseInt(index);
+    return acc[i < 0 ? acc.length + i : i];
+  }
+  return acc[index];
+}, value);
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/isSet.js
+var isSet = (value) => value != null;
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/ite.js
+function ite(condition, trueValue, falseValue) {
+  return condition ? trueValue : falseValue;
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/not.js
+var not = (value) => !value;
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/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/core/dist-es/submodules/endpoints/util-endpoints/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/core/dist-es/submodules/endpoints/util-endpoints/lib/split.js
+function split(value, delimiter, limit) {
+  if (limit === 1) {
+    return [value];
+  }
+  if (value === "") {
+    return [""];
+  }
+  const parts = value.split(delimiter);
+  if (limit === 0) {
+    return parts;
+  }
+  return parts.slice(0, limit - 1).concat(parts.slice(1).join(delimiter));
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/stringEquals.js
+var stringEquals = (value1, value2) => value1 === value2;
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/substring.js
+var substring = (input, start, stop, reverse) => {
+  if (input == null || start >= stop || input.length < stop || /[^\u0000-\u007f]/.test(input)) {
+    return null;
+  }
+  if (!reverse) {
+    return input.substring(start, stop);
+  }
+  return input.substring(input.length - stop, input.length - start);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/uriEncode.js
+var uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/endpointFunctions.js
+var endpointFunctions = {
+  booleanEquals,
+  coalesce,
+  getAttr,
+  isSet,
+  isValidHostLabel,
+  ite,
+  not,
+  parseURL,
+  split,
+  stringEquals,
+  substring,
+  uriEncode
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateTemplate.js
+var evaluateTemplate = (template, options) => {
+  const evaluatedTemplateArr = [];
+  const { referenceRecord, endpointParams } = options;
+  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(referenceRecord[refName] ?? endpointParams[refName], attrName));
+    } else {
+      evaluatedTemplateArr.push(referenceRecord[parameterName] ?? endpointParams[parameterName]);
+    }
+    currentIndex = closingBraceIndex + 1;
+  }
+  return evaluatedTemplateArr.join("");
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/getReferenceValue.js
+var getReferenceValue = ({ ref }, options) => {
+  return options.referenceRecord[ref] ?? options.endpointParams[ref];
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/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 = Array(argv.length);
+  for (let i = 0; i < evaluatedArgs.length; ++i) {
+    const arg = argv[i];
+    if (typeof arg === "boolean" || typeof arg === "number") {
+      evaluatedArgs[i] = arg;
+    } else {
+      evaluatedArgs[i] = group.evaluateExpression(arg, "arg", options);
+    }
+  }
+  const namespaceSeparatorIndex = fn.indexOf(".");
+  if (namespaceSeparatorIndex !== -1) {
+    const namespaceFunctions = customEndpointFunctions[fn.slice(0, namespaceSeparatorIndex)];
+    const customFunction = namespaceFunctions?.[fn.slice(namespaceSeparatorIndex + 1)];
+    if (typeof customFunction === "function") {
+      return customFunction(...evaluatedArgs);
+    }
+  }
+  const callable = endpointFunctions[fn];
+  if (typeof callable === "function") {
+    return callable(...evaluatedArgs);
+  }
+  throw new Error(`function ${fn} not loaded in endpointFunctions.`);
+};
+var group = {
+  evaluateExpression,
+  callFunction
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/evaluateCondition.js
+var evaluateCondition = (condition, options) => {
+  const { assign } = condition;
+  if (assign && assign in options.referenceRecord) {
+    throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
+  }
+  const value = callFunction(condition, options);
+  options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(condition)} = ${toDebugString(value)}`);
+  const result = value === "" ? true : !!value;
+  if (assign != null) {
+    return { result, toAssign: { name: assign, value } };
+  }
+  return { result };
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/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;
+  });
+  return acc;
+}, {});
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/utils/getEndpointProperties.js
+var getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => {
+  acc[propertyKey] = group2.getEndpointProperty(propertyVal, options);
+  return acc;
+}, {});
+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/core/dist-es/submodules/endpoints/util-endpoints/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/core/dist-es/submodules/endpoints/util-endpoints/decideEndpoint.js
+var RESULT = 1e8;
+var decideEndpoint = (bdd, options) => {
+  const { nodes, root, results, conditions } = bdd;
+  let ref = root;
+  const referenceRecord = {};
+  const closure = {
+    referenceRecord,
+    endpointParams: options.endpointParams,
+    logger: options.logger
+  };
+  while (ref !== 1 && ref !== -1 && ref < RESULT) {
+    const node_i = 3 * (Math.abs(ref) - 1);
+    const [condition_i, highRef, lowRef] = [nodes[node_i], nodes[node_i + 1], nodes[node_i + 2]];
+    const [fn, argv, assign] = conditions[condition_i];
+    const evaluation = evaluateCondition({ fn, assign, argv }, closure);
+    if (evaluation.toAssign) {
+      const { name, value } = evaluation.toAssign;
+      referenceRecord[name] = value;
+    }
+    ref = ref >= 0 === evaluation.result ? highRef : lowRef;
+  }
+  if (ref >= RESULT) {
+    const result = results[ref - RESULT];
+    if (result[0] === -1) {
+      const [, errorExpression] = result;
+      throw new EndpointError(evaluateExpression(errorExpression, "Error", closure));
+    }
+    const [url, properties, headers] = result;
+    return {
+      url: getEndpointUrl(url, closure),
+      properties: getEndpointProperties(properties, closure),
+      headers: getEndpointHeaders(headers ?? {}, closure)
+    };
+  }
+  throw new EndpointError(`No matching endpoint.`);
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/endpoints/index.js
+var getEndpointFromInstructions = bindGetEndpointFromInstructions(getEndpointFromConfig);
+var resolveEndpointConfig = bindResolveEndpointConfig(getEndpointFromConfig);
+var endpointMiddleware = bindEndpointMiddleware(getEndpointFromConfig);
+var getEndpointPlugin = bindGetEndpointPlugin(getEndpointFromConfig);
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/service-error-classification/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", "EAI_AGAIN"];
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/service-error-classification/service-error-classification.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) || error.name === "InvalidSignatureException" && error.message?.includes("Signature expired") || 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) || isNodeJsHttp2TransientError(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;
+};
+function isNodeJsHttp2TransientError(error) {
+  return error.code === "ERR_HTTP2_STREAM_ERROR" && error.message.includes("NGHTTP2_REFUSED_STREAM");
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/util-retry/DefaultRateLimiter.js
+var DefaultRateLimiter = class _DefaultRateLimiter {
+  static setTimeoutFn = setTimeout;
+  beta;
+  minCapacity;
+  minFillRate;
+  scaleConstant;
+  smooth;
+  enabled = false;
+  availableTokens = 0;
+  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;
+    this.lastThrottleTime = this.getCurrentTimeInSeconds();
+    this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
+    this.fillRate = this.minFillRate;
+    this.maxCapacity = this.minCapacity;
+  }
+  async getSendToken() {
+    return this.acquireTokenBucket(1);
+  }
+  updateClientSendingRate(response) {
+    let calculatedRate;
+    this.updateMeasuredRate();
+    const retryErrorInfo = response;
+    const isThrottling = retryErrorInfo?.errorType === "THROTTLING" || isThrottlingError(retryErrorInfo?.error ?? response);
+    if (isThrottling) {
+      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);
+  }
+  getCurrentTimeInSeconds() {
+    return Date.now() / 1e3;
+  }
+  async acquireTokenBucket(amount) {
+    if (!this.enabled) {
+      return;
+    }
+    this.refillTokenBucket();
+    while (amount > this.availableTokens) {
+      const delay = (amount - this.availableTokens) / this.fillRate * 1e3;
+      await new Promise((resolve) => _DefaultRateLimiter.setTimeoutFn(resolve, delay));
+      this.refillTokenBucket();
+    }
+    this.availableTokens = this.availableTokens - amount;
+  }
+  refillTokenBucket() {
+    const timestamp = this.getCurrentTimeInSeconds();
+    if (!this.lastTimestamp) {
+      this.lastTimestamp = timestamp;
+      return;
+    }
+    const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
+    this.availableTokens = Math.min(this.maxCapacity, this.availableTokens + fillAmount);
+    this.lastTimestamp = timestamp;
+  }
+  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.availableTokens = Math.min(this.availableTokens, 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/core/dist-es/submodules/retry/util-retry/constants.js
+var MAXIMUM_RETRY_DELAY = 20 * 1e3;
+var INITIAL_RETRY_TOKENS = 500;
+var NO_RETRY_INCREMENT = 1;
+var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
+var REQUEST_HEADER = "amz-sdk-request";
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/util-retry/retries-2026-config.js
+var Retry = class _Retry {
+  static v2026 = typeof process !== "undefined" && process.env?.SMITHY_NEW_RETRIES_2026 === "true";
+  static delay() {
+    return _Retry.v2026 ? 50 : 100;
+  }
+  static throttlingDelay() {
+    return _Retry.v2026 ? 1e3 : 500;
+  }
+  static cost() {
+    return _Retry.v2026 ? 14 : 5;
+  }
+  static throttlingCost() {
+    return _Retry.v2026 ? 5 : 10;
+  }
+  static modifiedCostType() {
+    return _Retry.v2026 ? "THROTTLING" : "TRANSIENT";
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/util-retry/DefaultRetryBackoffStrategy.js
+var DefaultRetryBackoffStrategy = class {
+  x = Retry.delay();
+  computeNextBackoffDelay(i) {
+    const b = Math.random();
+    const r = 2;
+    const t_i = b * Math.min(this.x * r ** i, MAXIMUM_RETRY_DELAY);
+    return Math.floor(t_i);
+  }
+  setDelayBase(delay) {
+    this.x = delay;
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/util-retry/DefaultRetryToken.js
+var DefaultRetryToken = class {
+  delay;
+  count;
+  cost;
+  longPoll;
+  $retryLog = {
+    acquisitionDelay: 0
+  };
+  constructor(delay, count, cost, longPoll) {
+    this.delay = delay;
+    this.count = count;
+    this.cost = cost;
+    this.longPoll = longPoll;
+  }
+  getRetryCount() {
+    return this.count;
+  }
+  getRetryDelay() {
+    return Math.min(MAXIMUM_RETRY_DELAY, this.delay);
+  }
+  getRetryCost() {
+    return this.cost;
+  }
+  isLongPoll() {
+    return this.longPoll;
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/util-retry/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/core/dist-es/submodules/retry/util-retry/StandardRetryStrategy.js
+var refusal = {
+  incompatible: 1,
+  attempts: 2,
+  capacity: 3
+};
+var StandardRetryStrategy = class {
+  mode = RETRY_MODES.STANDARD;
+  retryBackoffStrategy;
+  capacity = INITIAL_RETRY_TOKENS;
+  maxAttemptsProvider;
+  baseDelay;
+  constructor(arg1) {
+    if (typeof arg1 === "number") {
+      this.maxAttemptsProvider = async () => arg1;
+    } else if (typeof arg1 === "function") {
+      this.maxAttemptsProvider = arg1;
+    } else if (arg1 && typeof arg1 === "object") {
+      this.maxAttemptsProvider = async () => arg1.maxAttempts;
+      this.baseDelay = arg1.baseDelay;
+      this.retryBackoffStrategy = arg1.backoff;
+    }
+    this.maxAttemptsProvider ??= async () => DEFAULT_MAX_ATTEMPTS;
+    this.baseDelay ??= Retry.delay();
+    this.retryBackoffStrategy ??= new DefaultRetryBackoffStrategy();
+  }
+  async acquireInitialRetryToken(retryTokenScope) {
+    return new DefaultRetryToken(Retry.delay(), 0, void 0, Retry.v2026 && retryTokenScope.includes(":longpoll"));
+  }
+  async refreshRetryTokenForRetry(token, errorInfo) {
+    const maxAttempts = await this.getMaxAttempts();
+    const retryCode = this.retryCode(token, errorInfo, maxAttempts);
+    const shouldRetry = retryCode === 0;
+    const isLongPoll = token.isLongPoll?.();
+    if (shouldRetry || isLongPoll) {
+      const errorType = errorInfo.errorType;
+      this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? Retry.throttlingDelay() : this.baseDelay);
+      const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
+      let retryDelay = delayFromErrorType;
+      if (errorInfo.retryAfterHint instanceof Date) {
+        retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5e3));
+      }
+      if (!shouldRetry) {
+        const longPollBackoff = Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0;
+        if (longPollBackoff > 0) {
+          await new Promise((r) => setTimeout(r, longPollBackoff));
+        }
+      } else {
+        const capacityCost = this.getCapacityCost(errorType);
+        this.capacity -= capacityCost;
+        const nextToken = new DefaultRetryToken(0, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
+        await new Promise((r) => setTimeout(r, retryDelay));
+        nextToken.$retryLog.acquisitionDelay = retryDelay;
+        return nextToken;
+      }
+    }
+    throw new Error("No retry token available");
+  }
+  recordSuccess(token) {
+    this.capacity = Math.min(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
+  }
+  getCapacity() {
+    return this.capacity;
+  }
+  async maxAttempts() {
+    return this.maxAttemptsProvider();
+  }
+  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;
+    }
+  }
+  retryCode(tokenToRenew, errorInfo, maxAttempts) {
+    const attempts = tokenToRenew.getRetryCount() + 1;
+    const retryableStatus = this.isRetryableError(errorInfo.errorType) ? 0 : refusal.incompatible;
+    const attemptStatus = attempts < maxAttempts ? 0 : refusal.attempts;
+    const capacityStatus = this.capacity >= this.getCapacityCost(errorInfo.errorType) ? 0 : refusal.capacity;
+    return retryableStatus || attemptStatus || capacityStatus;
+  }
+  getCapacityCost(errorType) {
+    return errorType === Retry.modifiedCostType() ? Retry.throttlingCost() : Retry.cost();
+  }
+  isRetryableError(errorType) {
+    return errorType === "THROTTLING" || errorType === "TRANSIENT";
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/util-retry/AdaptiveRetryStrategy.js
+var AdaptiveRetryStrategy = class {
+  mode = RETRY_MODES.ADAPTIVE;
+  rateLimiter;
+  standardRetryStrategy;
+  constructor(maxAttemptsProvider, options) {
+    const { rateLimiter } = options ?? {};
+    this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
+    this.standardRetryStrategy = options ? new StandardRetryStrategy({
+      maxAttempts: typeof maxAttemptsProvider === "number" ? maxAttemptsProvider : 3,
+      ...options
+    }) : new StandardRetryStrategy(maxAttemptsProvider);
+  }
+  async acquireInitialRetryToken(retryTokenScope) {
+    const token = await this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
+    await this.rateLimiter.getSendToken();
+    return token;
+  }
+  async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
+    this.rateLimiter.updateClientSendingRate(errorInfo);
+    const token = await this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+    await this.rateLimiter.getSendToken();
+    return token;
+  }
+  recordSuccess(token) {
+    this.rateLimiter.updateClientSendingRate({});
+    this.standardRetryStrategy.recordSuccess(token);
+  }
+  async maxAttemptsProvider() {
+    return this.standardRetryStrategy.maxAttempts();
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/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, defaults) => {
+  const { retryStrategy, retryMode } = input;
+  const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
+  const maxAttemptsProvider = normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
+  let controller = retryStrategy ? Promise.resolve(retryStrategy) : void 0;
+  const getDefault = async () => {
+    const maxAttempts = await maxAttemptsProvider();
+    const adaptive = await normalizeProvider(retryMode)() === RETRY_MODES.ADAPTIVE;
+    if (adaptive) {
+      return new AdaptiveRetryStrategy(maxAttemptsProvider, {
+        maxAttempts,
+        baseDelay: defaultBaseDelay
+      });
+    }
+    return new StandardRetryStrategy({
+      maxAttempts,
+      baseDelay: defaultBaseDelay
+    });
+  };
+  return Object.assign(input, {
+    maxAttempts: maxAttemptsProvider,
+    retryStrategy: () => controller ??= getDefault()
+  });
+};
+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/core/dist-es/submodules/retry/middleware-retry/isStreamingPayload/isStreamingPayload.js
+import { Readable } from "stream";
+var isStreamingPayload = (request) => request?.body instanceof Readable || typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream;
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/parseRetryAfterHeader.js
+function parseRetryAfterHeader(response, logger) {
+  if (!HttpResponse.isInstance(response)) {
+    return;
+  }
+  for (const header of Object.keys(response.headers)) {
+    const h = header.toLowerCase();
+    if (h === "retry-after") {
+      const retryAfter = response.headers[header];
+      let retryAfterSeconds = NaN;
+      if (retryAfter.endsWith("GMT")) {
+        try {
+          const date = parseRfc7231DateTime(retryAfter);
+          retryAfterSeconds = (date.getTime() - Date.now()) / 1e3;
+        } catch (e) {
+          logger?.trace?.("Failed to parse retry-after header");
+          logger?.trace?.(e);
+        }
+      } else if (retryAfter.match(/ GMT, ((\d+)|(\d+\.\d+))$/)) {
+        retryAfterSeconds = Number(retryAfter.match(/ GMT, ([\d.]+)$/)?.[1]);
+      } else if (retryAfter.match(/^((\d+)|(\d+\.\d+))$/)) {
+        retryAfterSeconds = Number(retryAfter);
+      } else if (Date.parse(retryAfter) >= Date.now()) {
+        retryAfterSeconds = (Date.parse(retryAfter) - Date.now()) / 1e3;
+      }
+      if (isNaN(retryAfterSeconds)) {
+        return;
+      }
+      return new Date(Date.now() + retryAfterSeconds * 1e3);
+    } else if (h === "x-amz-retry-after") {
+      const v = response.headers[header];
+      const backoffMilliseconds = Number(v);
+      if (isNaN(backoffMilliseconds)) {
+        logger?.trace?.(`Failed to parse x-amz-retry-after=${v}`);
+        return;
+      }
+      return new Date(Date.now() + backoffMilliseconds);
+    }
+  }
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/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/core/dist-es/submodules/retry/middleware-retry/retryMiddleware.js
+function bindRetryMiddleware(isStreamingPayload2) {
+  return (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"] ?? "") + (context.__retryLongPoll ? ":longpoll" : ""));
+      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, options.logger);
+          lastError = asSdkError(e);
+          if (isRequest && isStreamingPayload2(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 += (retryToken?.$retryLog?.acquisitionDelay ?? 0) + delay;
+          if (delay > 0) {
+            await cooldown(delay);
+          }
+        }
+      }
+    } else {
+      retryStrategy = retryStrategy;
+      if (retryStrategy?.mode) {
+        context.userAgent = [...context.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]];
+      }
+      return retryStrategy.retry(next, args);
+    }
+  };
+}
+var cooldown = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && typeof retryStrategy.recordSuccess !== "undefined";
+var getRetryErrorInfo = (error, logger) => {
+  const errorInfo = {
+    error,
+    errorType: getRetryErrorType(error)
+  };
+  const retryAfterHint = parseRetryAfterHeader(error.$response, logger);
+  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
+};
+function bindGetRetryPlugin(isStreamingPayload2) {
+  const retryMiddleware2 = bindRetryMiddleware(isStreamingPayload2);
+  return (options) => ({
+    applyToStack: (clientStack) => {
+      clientStack.add(retryMiddleware2(options), retryMiddlewareOptions);
+    }
+  });
+}
+
+// ../../node_modules/@smithy/core/dist-es/submodules/retry/index.js
+var retryMiddleware = bindRetryMiddleware(isStreamingPayload);
+var getRetryPlugin = bindGetRetryPlugin(isStreamingPayload);
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-host-header/hostHeaderMiddleware.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/core/dist-es/submodules/client/middleware-logger/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/core/dist-es/submodules/client/middleware-recursion-detection/configuration.js
+var recursionDetectionMiddlewareOptions = {
+  step: "build",
+  tags: ["RECURSION_DETECTION"],
+  name: "recursionDetectionMiddleware",
+  override: true,
+  priority: "low"
+};
+
+// ../../node_modules/@aws/lambda-invoke-store/dist-es/invoke-store.js
+var PROTECTED_KEYS = {
+  REQUEST_ID: /* @__PURE__ */ Symbol.for("_AWS_LAMBDA_REQUEST_ID"),
+  X_RAY_TRACE_ID: /* @__PURE__ */ Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"),
+  TENANT_ID: /* @__PURE__ */ Symbol.for("_AWS_LAMBDA_TENANT_ID")
+};
+var NO_GLOBAL_AWS_LAMBDA = ["true", "1"].includes(process.env?.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA ?? "");
+if (!NO_GLOBAL_AWS_LAMBDA) {
+  globalThis.awslambda = globalThis.awslambda || {};
+}
+var InvokeStoreBase = class {
+  static PROTECTED_KEYS = PROTECTED_KEYS;
+  isProtectedKey(key) {
+    return Object.values(PROTECTED_KEYS).includes(key);
+  }
+  getRequestId() {
+    return this.get(PROTECTED_KEYS.REQUEST_ID) ?? "-";
+  }
+  getXRayTraceId() {
+    return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID);
+  }
+  getTenantId() {
+    return this.get(PROTECTED_KEYS.TENANT_ID);
+  }
+};
+var InvokeStoreSingle = class extends InvokeStoreBase {
+  currentContext;
+  getContext() {
+    return this.currentContext;
+  }
+  hasContext() {
+    return this.currentContext !== void 0;
+  }
+  get(key) {
+    return this.currentContext?.[key];
+  }
+  set(key, value) {
+    if (this.isProtectedKey(key)) {
+      throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
+    }
+    this.currentContext = this.currentContext || {};
+    this.currentContext[key] = value;
+  }
+  run(context, fn) {
+    this.currentContext = context;
+    return fn();
+  }
+};
+var InvokeStoreMulti = class _InvokeStoreMulti extends InvokeStoreBase {
+  als;
+  static async create() {
+    const instance = new _InvokeStoreMulti();
+    const asyncHooks = await import("async_hooks");
+    instance.als = new asyncHooks.AsyncLocalStorage();
+    return instance;
+  }
+  getContext() {
+    return this.als.getStore();
+  }
+  hasContext() {
+    return this.als.getStore() !== void 0;
+  }
+  get(key) {
+    return this.als.getStore()?.[key];
+  }
+  set(key, value) {
+    if (this.isProtectedKey(key)) {
+      throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
+    }
+    const store = this.als.getStore();
+    if (!store) {
+      throw new Error("No context available");
+    }
+    store[key] = value;
+  }
+  run(context, fn) {
+    return this.als.run(context, fn);
+  }
+};
+var InvokeStore;
+(function(InvokeStore2) {
+  let instance = null;
+  async function getInstanceAsync(forceInvokeStoreMulti) {
+    if (!instance) {
+      instance = (async () => {
+        const isMulti = forceInvokeStoreMulti === true || "AWS_LAMBDA_MAX_CONCURRENCY" in process.env;
+        const newInstance = isMulti ? await InvokeStoreMulti.create() : new InvokeStoreSingle();
+        if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda?.InvokeStore) {
+          return globalThis.awslambda.InvokeStore;
+        } else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) {
+          globalThis.awslambda.InvokeStore = newInstance;
+          return newInstance;
+        } else {
+          return newInstance;
+        }
+      })();
+    }
+    return instance;
+  }
+  InvokeStore2.getInstanceAsync = getInstanceAsync;
+  InvokeStore2._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === "1" ? {
+    reset: () => {
+      instance = null;
+      if (globalThis.awslambda?.InvokeStore) {
+        delete globalThis.awslambda.InvokeStore;
+      }
+      globalThis.awslambda = { InvokeStore: void 0 };
+    }
+  } : void 0;
+})(InvokeStore || (InvokeStore = {}));
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-recursion-detection/recursionDetectionMiddleware.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 = () => (next) => async (args) => {
+  const { request } = args;
+  if (!HttpRequest.isInstance(request)) {
+    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 traceIdFromEnv = process.env[ENV_TRACE_ID];
+  const invokeStore = await InvokeStore.getInstanceAsync();
+  const traceIdFromInvokeStore = invokeStore?.getXRayTraceId();
+  const traceId = traceIdFromInvokeStore ?? traceIdFromEnv;
+  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
+  });
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-recursion-detection/getRecursionDetectionPlugin.js
+var getRecursionDetectionPlugin = (options) => ({
+  applyToStack: (clientStack) => {
+    clientStack.add(recursionDetectionMiddleware(), recursionDetectionMiddlewareOptions);
+  }
+});
+
+// ../../node_modules/@smithy/core/dist-es/legacy-root-exports/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/legacy-root-exports/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/legacy-root-exports/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/core/dist-es/legacy-root-exports/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/legacy-root-exports/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/legacy-root-exports/pagination/createPaginator.js
+var makePagedClientRequest = async (CommandCtor, client, input, withCommand = (_) => _, ...args) => {
+  let command = new CommandCtor(input);
+  command = withCommand(command) ?? command;
+  return await client.send(command, ...args);
+};
+function createPaginator(ClientCtor, CommandCtor, inputTokenName, outputTokenName, pageSizeTokenName) {
+  return async function* paginateOperation(config, input, ...additionalArguments) {
+    const _input = input;
+    let token = config.startingToken ?? _input[inputTokenName];
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+      _input[inputTokenName] = token;
+      if (pageSizeTokenName) {
+        _input[pageSizeTokenName] = _input[pageSizeTokenName] ?? config.pageSize;
+      }
+      if (config.client instanceof ClientCtor) {
+        page = await makePagedClientRequest(CommandCtor, config.client, input, config.withCommand, ...additionalArguments);
+      } else {
+        throw new Error(`Invalid client, expected instance of ${ClientCtor.name}`);
+      }
+      yield page;
+      const prevToken = token;
+      token = get(page, outputTokenName);
+      hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return void 0;
+  };
+}
+var get = (fromObject, path) => {
+  let cursor = fromObject;
+  const pathComponents = path.split(".");
+  for (const step of pathComponents) {
+    if (!cursor || typeof cursor !== "object") {
+      return void 0;
+    }
+    cursor = cursor[step];
+  }
+  return cursor;
+};
+
+// ../../node_modules/@smithy/core/dist-es/legacy-root-exports/util-identity-and-auth/DefaultIdentityProviderConfig.js
+var DefaultIdentityProviderConfig = class {
+  authSchemes = /* @__PURE__ */ new Map();
+  constructor(config) {
+    for (const key in config) {
+      const value = config[key];
+      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/core/dist-es/legacy-root-exports/util-identity-and-auth/httpAuthSchemes/noAuth.js
+var NoAuthSigner = class {
+  async sign(httpRequest, identity, signingProperties) {
+    return httpRequest;
+  }
+};
+
+// ../../node_modules/@smithy/core/dist-es/legacy-root-exports/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/core/dist-es/submodules/client/middleware-user-agent/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/@aws-sdk/core/dist-es/submodules/client/util-endpoints/lib/aws/partitions.js
+var partitionsInfo = { "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-6": { "description": "Asia Pacific (New Zealand)" }, "ap-southeast-7": { "description": "Asia Pacific (Thailand)" }, "aws-global": { "description": "aws 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-cn global region" }, "cn-north-1": { "description": "China (Beijing)" }, "cn-northwest-1": { "description": "China (Ningxia)" } } }, { "id": "aws-eusc", "outputs": { "dnsSuffix": "amazonaws.eu", "dualStackDnsSuffix": "api.amazonwebservices.eu", "implicitGlobalRegion": "eusc-de-east-1", "name": "aws-eusc", "supportsDualStack": true, "supportsFIPS": true }, "regionRegex": "^eusc\\-(de)\\-\\w+\\-\\d+$", "regions": { "eusc-de-east-1": { "description": "AWS European Sovereign Cloud (Germany)" } } }, { "id": "aws-iso", "outputs": { "dnsSuffix": "c2s.ic.gov", "dualStackDnsSuffix": "api.aws.ic.gov", "implicitGlobalRegion": "us-iso-east-1", "name": "aws-iso", "supportsDualStack": true, "supportsFIPS": true }, "regionRegex": "^us\\-iso\\-\\w+\\-\\d+$", "regions": { "aws-iso-global": { "description": "aws-iso 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": "api.aws.scloud", "implicitGlobalRegion": "us-isob-east-1", "name": "aws-iso-b", "supportsDualStack": true, "supportsFIPS": true }, "regionRegex": "^us\\-isob\\-\\w+\\-\\d+$", "regions": { "aws-iso-b-global": { "description": "aws-iso-b global region" }, "us-isob-east-1": { "description": "US ISOB East (Ohio)" }, "us-isob-west-1": { "description": "US ISOB West" } } }, { "id": "aws-iso-e", "outputs": { "dnsSuffix": "cloud.adc-e.uk", "dualStackDnsSuffix": "api.cloud-aws.adc-e.uk", "implicitGlobalRegion": "eu-isoe-west-1", "name": "aws-iso-e", "supportsDualStack": true, "supportsFIPS": true }, "regionRegex": "^eu\\-isoe\\-\\w+\\-\\d+$", "regions": { "aws-iso-e-global": { "description": "aws-iso-e global region" }, "eu-isoe-west-1": { "description": "EU ISOE West" } } }, { "id": "aws-iso-f", "outputs": { "dnsSuffix": "csp.hci.ic.gov", "dualStackDnsSuffix": "api.aws.hci.ic.gov", "implicitGlobalRegion": "us-isof-south-1", "name": "aws-iso-f", "supportsDualStack": true, "supportsFIPS": true }, "regionRegex": "^us\\-isof\\-\\w+\\-\\d+$", "regions": { "aws-iso-f-global": { "description": "aws-iso-f global region" }, "us-isof-east-1": { "description": "US ISOF EAST" }, "us-isof-south-1": { "description": "US ISOF SOUTH" } } }, { "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-us-gov global region" }, "us-gov-east-1": { "description": "AWS GovCloud (US-East)" }, "us-gov-west-1": { "description": "AWS GovCloud (US-West)" } } }], "version": "1.1" };
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-endpoints/lib/aws/partition.js
+var selectedPartitionsInfo = partitionsInfo;
+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/core/dist-es/submodules/client/setFeature.js
+Retry.v2026 ||= typeof process === "object" && process.env?.AWS_NEW_RETRIES_2026 === "true";
+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/client/middleware-user-agent/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.mode === "string") {
+      switch (retryStrategy.mode) {
+        case RETRY_MODES.ADAPTIVE:
+          setFeature2(context, "RETRY_MODE_ADAPTIVE", "F");
+          break;
+        case RETRY_MODES.STANDARD:
+          setFeature2(context, "RETRY_MODE_STANDARD", "E");
+          break;
+      }
+    }
+  }
+  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/core/dist-es/submodules/client/middleware-user-agent/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 = /[^!$%&'*+\-.^_`|~\w]/g;
+var UA_VALUE_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w#]/g;
+var UA_ESCAPE_CHAR = "-";
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/middleware-user-agent/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/core/dist-es/submodules/client/middleware-user-agent/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 defaultUserAgent2 = (await options.defaultUserAgentProvider()).map(escapeUserAgent);
+  await checkFeatures(context, options, args);
+  const awsContext = context;
+  defaultUserAgent2.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) {
+    defaultUserAgent2.push(escapeUserAgent([`app`, `${appId}`]));
+  }
+  const prefix = getUserAgentPrefix();
+  const sdkUserAgentValue = (prefix ? [prefix] : []).concat([...defaultUserAgent2, ...userAgent, ...customUserAgent]).join(SPACE);
+  const normalUAValue = [
+    ...defaultUserAgent2.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/@aws-sdk/core/dist-es/submodules/client/emitWarningIfUnsupportedVersion.js
+var state = {
+  warningEmitted: false
+};
+var emitWarningIfUnsupportedVersion2 = (version) => {
+  if (version && !state.warningEmitted) {
+    if (process.env.AWS_SDK_JS_NODE_VERSION_SUPPORT_WARNING_DISABLED === "true") {
+      state.warningEmitted = true;
+      return;
+    }
+    const userMajorVersion = parseInt(version.substring(1, version.indexOf(".")));
+    const vv = 22;
+    if (userMajorVersion < vv) {
+      state.warningEmitted = true;
+      process.emitWarning(`NodeVersionSupportWarning: The AWS SDK for JavaScript (v3)
+versions published after the first week of January 2027
+will require node >=${vv}. You are running node ${version}.
+
+To continue receiving updates to AWS services, bug fixes,
+and security updates please upgrade to node >=${vv}.
+
+More information can be found at: https://a.co/c895JFp`);
+    }
+  }
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/defaultUserAgent.js
+import { platform, release } from "os";
+import { env } from "process";
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getRuntimeUserAgentPair.js
+import { versions } from "process";
+var getRuntimeUserAgentPair = () => {
+  const runtimesToCheck = ["deno", "bun", "llrt"];
+  for (const runtime of runtimesToCheck) {
+    if (versions[runtime]) {
+      return [`md/${runtime}`, versions[runtime]];
+    }
+  }
+  return ["md/nodejs", versions.node];
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getTypeScriptUserAgentPair.js
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getNodeModulesParentDirs.js
+import { normalize, sep } from "path";
+var getNodeModulesParentDirs = (dirname) => {
+  const cwd = process.cwd();
+  if (!dirname) {
+    return [cwd];
+  }
+  const normalizedPath = normalize(dirname);
+  const parts = normalizedPath.split(sep);
+  const nodeModulesIndex = parts.indexOf("node_modules");
+  const parentDir = nodeModulesIndex !== -1 ? parts.slice(0, nodeModulesIndex).join(sep) : normalizedPath;
+  if (cwd === parentDir) {
+    return [cwd];
+  }
+  return [parentDir, cwd];
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getSanitizedTypeScriptVersion.js
+var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)?$/;
+var getSanitizedTypeScriptVersion = (version = "") => {
+  const match = version.match(SEMVER_REGEX);
+  if (!match) {
+    return void 0;
+  }
+  const [major, minor, patch, prerelease] = [match[1], match[2], match[3], match[4]];
+  return prerelease ? `${major}.${minor}.${patch}-${prerelease}` : `${major}.${minor}.${patch}`;
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getSanitizedDevTypeScriptVersion.js
+var ALLOWED_PREFIXES = ["^", "~", ">=", "<=", ">", "<"];
+var ALLOWED_DIST_TAGS = ["latest", "beta", "dev", "rc", "insiders", "next"];
+var getSanitizedDevTypeScriptVersion = (version = "") => {
+  if (ALLOWED_DIST_TAGS.includes(version)) {
+    return version;
+  }
+  const prefix = ALLOWED_PREFIXES.find((p) => version.startsWith(p)) ?? "";
+  const sanitizedTypeScriptVersion = getSanitizedTypeScriptVersion(version.slice(prefix.length));
+  if (!sanitizedTypeScriptVersion) {
+    return void 0;
+  }
+  return `${prefix}${sanitizedTypeScriptVersion}`;
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getTypeScriptUserAgentPair.js
+var tscVersion;
+var TS_PACKAGE_JSON = join("node_modules", "typescript", "package.json");
+var getTypeScriptUserAgentPair = async () => {
+  if (tscVersion === null) {
+    return void 0;
+  } else if (typeof tscVersion === "string") {
+    return ["md/tsc", tscVersion];
+  }
+  let isTypeScriptDetectionDisabled = false;
+  try {
+    isTypeScriptDetectionDisabled = booleanSelector(process.env, "AWS_SDK_JS_TYPESCRIPT_DETECTION_DISABLED", SelectorType.ENV) || false;
+  } catch {
+  }
+  if (isTypeScriptDetectionDisabled) {
+    tscVersion = null;
+    return void 0;
+  }
+  const dirname = typeof __dirname !== "undefined" ? __dirname : void 0;
+  const nodeModulesParentDirs = getNodeModulesParentDirs(dirname);
+  let versionFromApp;
+  for (const nodeModulesParentDir of nodeModulesParentDirs) {
+    try {
+      const appPackageJsonPath = join(nodeModulesParentDir, "package.json");
+      const packageJson = await readFile(appPackageJsonPath, "utf-8");
+      const { dependencies, devDependencies } = JSON.parse(packageJson);
+      const version = devDependencies?.typescript ?? dependencies?.typescript;
+      if (typeof version !== "string") {
+        continue;
+      }
+      versionFromApp = version;
+      break;
+    } catch {
+    }
+  }
+  if (!versionFromApp) {
+    tscVersion = null;
+    return void 0;
+  }
+  let versionFromNodeModules;
+  for (const nodeModulesParentDir of nodeModulesParentDirs) {
+    try {
+      const tsPackageJsonPath = join(nodeModulesParentDir, TS_PACKAGE_JSON);
+      const packageJson = await readFile(tsPackageJsonPath, "utf-8");
+      const { version } = JSON.parse(packageJson);
+      const sanitizedVersion2 = getSanitizedTypeScriptVersion(version);
+      if (typeof sanitizedVersion2 !== "string") {
+        continue;
+      }
+      versionFromNodeModules = sanitizedVersion2;
+      break;
+    } catch {
+    }
+  }
+  if (versionFromNodeModules) {
+    tscVersion = versionFromNodeModules;
+    return ["md/tsc", tscVersion];
+  }
+  const sanitizedVersion = getSanitizedDevTypeScriptVersion(versionFromApp);
+  if (typeof sanitizedVersion !== "string") {
+    tscVersion = null;
+    return void 0;
+  }
+  tscVersion = `dev_${sanitizedVersion}`;
+  return ["md/tsc", tscVersion];
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/crt-availability.js
+var crtAvailability = {
+  isCrtAvailable: false
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/is-crt-available.js
+var isCrtAvailable = () => {
+  if (crtAvailability.isCrtAvailable) {
+    return ["md/crt-avail"];
+  }
+  return null;
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/defaultUserAgent.js
+var createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
+  const runtimeUserAgentPair = getRuntimeUserAgentPair();
+  return async (config) => {
+    const sections = [
+      ["aws-sdk-js", clientVersion],
+      ["ua", "2.1"],
+      [`os/${platform()}`, release()],
+      ["lang/js"],
+      runtimeUserAgentPair
+    ];
+    const typescriptUserAgentPair = await getTypeScriptUserAgentPair();
+    if (typescriptUserAgentPair) {
+      sections.push(typescriptUserAgentPair);
+    }
+    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/core/dist-es/submodules/client/util-user-agent-node/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/@aws-sdk/core/dist-es/submodules/client/util-endpoints/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/core/dist-es/submodules/client/util-endpoints/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/core/dist-es/submodules/client/util-endpoints/aws.js
+var awsEndpointFunctions = {
+  isVirtualHostableS3Bucket,
+  parseArn,
+  partition
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/region-config-resolver/stsRegionDefaultResolver.js
+function stsRegionDefaultResolver(loaderConfig = {}) {
+  return loadConfig({
+    ...NODE_REGION_CONFIG_OPTIONS,
+    async default() {
+      if (!warning.silence) {
+        console.warn("@aws-sdk - WARN - default STS region of us-east-1 used. See @aws-sdk/credential-providers README and set a region explicitly.");
+      }
+      return "us-east-1";
+    }
+  }, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig });
+}
+var warning = {
+  silence: false
+};
+
+// ../../node_modules/@aws-sdk/core/dist-es/submodules/client/region-config-resolver/extensions.js
+var getAwsRegionExtensionConfiguration = (runtimeConfig) => {
+  return {
+    setRegion(region) {
+      runtimeConfig.region = region;
+    },
+    region() {
+      return runtimeConfig.region;
+    }
+  };
+};
+var resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) => {
+  return {
+    region: awsRegionExtensionConfiguration.region()
+  };
+};
+
+export {
+  emitWarningIfUnsupportedVersion2 as emitWarningIfUnsupportedVersion,
+  setCredentialFeature,
+  WaiterState,
+  checkExceptions,
+  createWaiter,
+  Client,
+  Command,
+  createAggregatedClient,
+  ServiceException,
+  decorateServiceException,
+  loadConfigsForDefaultMode,
+  emitWarningIfUnsupportedVersion as emitWarningIfUnsupportedVersion2,
+  getDefaultExtensionConfiguration,
+  resolveDefaultRuntimeConfig,
+  getValueFromTextNode,
+  NoOpLogger,
+  resolveParams,
+  BinaryDecisionDiagram,
+  EndpointCache,
+  customEndpointFunctions,
+  decideEndpoint,
+  resolveEndpointConfig,
+  getEndpointPlugin,
+  DEFAULT_RETRY_MODE,
+  NODE_MAX_ATTEMPT_CONFIG_OPTIONS,
+  resolveRetryConfig,
+  NODE_RETRY_MODE_CONFIG_OPTIONS,
+  getRetryPlugin,
+  resolveHostHeaderConfig,
+  getHostHeaderPlugin,
+  getLoggerPlugin,
+  getRecursionDetectionPlugin,
+  getHttpAuthSchemeEndpointRuleSetPlugin,
+  getHttpSigningPlugin,
+  normalizeProvider2 as normalizeProvider,
+  createPaginator,
+  DefaultIdentityProviderConfig,
+  NoAuthSigner,
+  isIdentityExpired,
+  doesIdentityRequireRefresh,
+  memoizeIdentityProvider,
+  resolveUserAgentConfig,
+  getUserAgentPlugin,
+  createDefaultUserAgentProvider,
+  NODE_APP_ID_CONFIG_OPTIONS,
+  awsEndpointFunctions,
+  stsRegionDefaultResolver,
+  getAwsRegionExtensionConfiguration,
+  resolveAwsRegionExtensionConfiguration
+};
+//# sourceMappingURL=chunk-7UD62TQI.js.map