@granite-js/pulumi-aws 0.1.34 → 1.0.2

package/dist/{chunk-5W7B34BN.js → chunk-ASGFIK4A.js}

@@ -1,36 +1,992 @@
 import {
   loadConfig,
+  memoize,
   parseUrl
-} from "./chunk-WCHHWTND.js";
+} from "./chunk-LCO5F3JB.js";
 import {
-  CONFIG_PREFIX_SEPARATOR
-} from "./chunk-KGNTV362.js";
-import {
-  HttpRequest,
   HttpResponse,
-  NoOpLogger,
-  collectBody,
   escapeUri,
-  fromArrayBuffer,
+  fromBase64,
   fromHex,
-  fromString,
-  fromUtf8,
-  isArrayBuffer,
-  toHex,
-  toUint8Array
-} from "./chunk-VOTRVWIB.js";
+  toBase64,
+  toHex
+} from "./chunk-OSJA4YYQ.js";
 import {
-  setCredentialFeature
-} from "./chunk-ITI6QA2Q.js";
+  HttpRequest
+} from "./chunk-NDDYFDCU.js";
 import {
-  EndpointURLScheme,
-  SMITHY_CONTEXT_KEY
-} from "./chunk-M5GUUX64.js";
+  CONFIG_PREFIX_SEPARATOR
+} from "./chunk-WDFKVCPC.js";
+import {
+  setCredentialFeature
+} from "./chunk-3OYGHA4S.js";
 import {
-  memoize
-} from "./chunk-W3VXP3A3.js";
+  fromArrayBuffer,
+  fromString,
+  fromUtf8,
+  isArrayBuffer,
+  toUtf8
+} from "./chunk-Z4UYYQ4J.js";
+
+// ../../.yarn/cache/@smithy-middleware-stack-npm-4.2.5-c2c432e836-c884760539.zip/node_modules/@smithy/middleware-stack/dist-es/MiddlewareStack.js
+var getAllAliases = (name, aliases) => {
+  const _aliases = [];
+  if (name) {
+    _aliases.push(name);
+  }
+  if (aliases) {
+    for (const alias of aliases) {
+      _aliases.push(alias);
+    }
+  }
+  return _aliases;
+};
+var getMiddlewareNameWithAliases = (name, aliases) => {
+  return `${name || "anonymous"}${aliases && aliases.length > 0 ? ` (a.k.a. ${aliases.join(",")})` : ""}`;
+};
+var constructStack = () => {
+  let absoluteEntries = [];
+  let relativeEntries = [];
+  let identifyOnResolve = false;
+  const entriesNameSet = /* @__PURE__ */ new Set();
+  const sort = (entries) => entries.sort((a, b) => stepWeights[b.step] - stepWeights[a.step] || priorityWeights[b.priority || "normal"] - priorityWeights[a.priority || "normal"]);
+  const removeByName = (toRemove) => {
+    let isRemoved = false;
+    const filterCb = (entry) => {
+      const aliases = getAllAliases(entry.name, entry.aliases);
+      if (aliases.includes(toRemove)) {
+        isRemoved = true;
+        for (const alias of aliases) {
+          entriesNameSet.delete(alias);
+        }
+        return false;
+      }
+      return true;
+    };
+    absoluteEntries = absoluteEntries.filter(filterCb);
+    relativeEntries = relativeEntries.filter(filterCb);
+    return isRemoved;
+  };
+  const removeByReference = (toRemove) => {
+    let isRemoved = false;
+    const filterCb = (entry) => {
+      if (entry.middleware === toRemove) {
+        isRemoved = true;
+        for (const alias of getAllAliases(entry.name, entry.aliases)) {
+          entriesNameSet.delete(alias);
+        }
+        return false;
+      }
+      return true;
+    };
+    absoluteEntries = absoluteEntries.filter(filterCb);
+    relativeEntries = relativeEntries.filter(filterCb);
+    return isRemoved;
+  };
+  const cloneTo = (toStack) => {
+    absoluteEntries.forEach((entry) => {
+      toStack.add(entry.middleware, { ...entry });
+    });
+    relativeEntries.forEach((entry) => {
+      toStack.addRelativeTo(entry.middleware, { ...entry });
+    });
+    toStack.identifyOnResolve?.(stack.identifyOnResolve());
+    return toStack;
+  };
+  const expandRelativeMiddlewareList = (from) => {
+    const expandedMiddlewareList = [];
+    from.before.forEach((entry) => {
+      if (entry.before.length === 0 && entry.after.length === 0) {
+        expandedMiddlewareList.push(entry);
+      } else {
+        expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
+      }
+    });
+    expandedMiddlewareList.push(from);
+    from.after.reverse().forEach((entry) => {
+      if (entry.before.length === 0 && entry.after.length === 0) {
+        expandedMiddlewareList.push(entry);
+      } else {
+        expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
+      }
+    });
+    return expandedMiddlewareList;
+  };
+  const getMiddlewareList = (debug = false) => {
+    const normalizedAbsoluteEntries = [];
+    const normalizedRelativeEntries = [];
+    const normalizedEntriesNameMap = {};
+    absoluteEntries.forEach((entry) => {
+      const normalizedEntry = {
+        ...entry,
+        before: [],
+        after: []
+      };
+      for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
+        normalizedEntriesNameMap[alias] = normalizedEntry;
+      }
+      normalizedAbsoluteEntries.push(normalizedEntry);
+    });
+    relativeEntries.forEach((entry) => {
+      const normalizedEntry = {
+        ...entry,
+        before: [],
+        after: []
+      };
+      for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
+        normalizedEntriesNameMap[alias] = normalizedEntry;
+      }
+      normalizedRelativeEntries.push(normalizedEntry);
+    });
+    normalizedRelativeEntries.forEach((entry) => {
+      if (entry.toMiddleware) {
+        const toMiddleware = normalizedEntriesNameMap[entry.toMiddleware];
+        if (toMiddleware === void 0) {
+          if (debug) {
+            return;
+          }
+          throw new Error(`${entry.toMiddleware} is not found when adding ${getMiddlewareNameWithAliases(entry.name, entry.aliases)} middleware ${entry.relation} ${entry.toMiddleware}`);
+        }
+        if (entry.relation === "after") {
+          toMiddleware.after.push(entry);
+        }
+        if (entry.relation === "before") {
+          toMiddleware.before.push(entry);
+        }
+      }
+    });
+    const mainChain = sort(normalizedAbsoluteEntries).map(expandRelativeMiddlewareList).reduce((wholeList, expandedMiddlewareList) => {
+      wholeList.push(...expandedMiddlewareList);
+      return wholeList;
+    }, []);
+    return mainChain;
+  };
+  const stack = {
+    add: (middleware, options = {}) => {
+      const { name, override, aliases: _aliases } = options;
+      const entry = {
+        step: "initialize",
+        priority: "normal",
+        middleware,
+        ...options
+      };
+      const aliases = getAllAliases(name, _aliases);
+      if (aliases.length > 0) {
+        if (aliases.some((alias) => entriesNameSet.has(alias))) {
+          if (!override)
+            throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`);
+          for (const alias of aliases) {
+            const toOverrideIndex = absoluteEntries.findIndex((entry2) => entry2.name === alias || entry2.aliases?.some((a) => a === alias));
+            if (toOverrideIndex === -1) {
+              continue;
+            }
+            const toOverride = absoluteEntries[toOverrideIndex];
+            if (toOverride.step !== entry.step || entry.priority !== toOverride.priority) {
+              throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware with ${toOverride.priority} priority in ${toOverride.step} step cannot be overridden by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware with ${entry.priority} priority in ${entry.step} step.`);
+            }
+            absoluteEntries.splice(toOverrideIndex, 1);
+          }
+        }
+        for (const alias of aliases) {
+          entriesNameSet.add(alias);
+        }
+      }
+      absoluteEntries.push(entry);
+    },
+    addRelativeTo: (middleware, options) => {
+      const { name, override, aliases: _aliases } = options;
+      const entry = {
+        middleware,
+        ...options
+      };
+      const aliases = getAllAliases(name, _aliases);
+      if (aliases.length > 0) {
+        if (aliases.some((alias) => entriesNameSet.has(alias))) {
+          if (!override)
+            throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`);
+          for (const alias of aliases) {
+            const toOverrideIndex = relativeEntries.findIndex((entry2) => entry2.name === alias || entry2.aliases?.some((a) => a === alias));
+            if (toOverrideIndex === -1) {
+              continue;
+            }
+            const toOverride = relativeEntries[toOverrideIndex];
+            if (toOverride.toMiddleware !== entry.toMiddleware || toOverride.relation !== entry.relation) {
+              throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware ${toOverride.relation} "${toOverride.toMiddleware}" middleware cannot be overridden by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware ${entry.relation} "${entry.toMiddleware}" middleware.`);
+            }
+            relativeEntries.splice(toOverrideIndex, 1);
+          }
+        }
+        for (const alias of aliases) {
+          entriesNameSet.add(alias);
+        }
+      }
+      relativeEntries.push(entry);
+    },
+    clone: () => cloneTo(constructStack()),
+    use: (plugin) => {
+      plugin.applyToStack(stack);
+    },
+    remove: (toRemove) => {
+      if (typeof toRemove === "string")
+        return removeByName(toRemove);
+      else
+        return removeByReference(toRemove);
+    },
+    removeByTag: (toRemove) => {
+      let isRemoved = false;
+      const filterCb = (entry) => {
+        const { tags, name, aliases: _aliases } = entry;
+        if (tags && tags.includes(toRemove)) {
+          const aliases = getAllAliases(name, _aliases);
+          for (const alias of aliases) {
+            entriesNameSet.delete(alias);
+          }
+          isRemoved = true;
+          return false;
+        }
+        return true;
+      };
+      absoluteEntries = absoluteEntries.filter(filterCb);
+      relativeEntries = relativeEntries.filter(filterCb);
+      return isRemoved;
+    },
+    concat: (from) => {
+      const cloned = cloneTo(constructStack());
+      cloned.use(from);
+      cloned.identifyOnResolve(identifyOnResolve || cloned.identifyOnResolve() || (from.identifyOnResolve?.() ?? false));
+      return cloned;
+    },
+    applyToStack: cloneTo,
+    identify: () => {
+      return getMiddlewareList(true).map((mw) => {
+        const step = mw.step ?? mw.relation + " " + mw.toMiddleware;
+        return getMiddlewareNameWithAliases(mw.name, mw.aliases) + " - " + step;
+      });
+    },
+    identifyOnResolve(toggle) {
+      if (typeof toggle === "boolean")
+        identifyOnResolve = toggle;
+      return identifyOnResolve;
+    },
+    resolve: (handler, context) => {
+      for (const middleware of getMiddlewareList().map((entry) => entry.middleware).reverse()) {
+        handler = middleware(handler, context);
+      }
+      if (identifyOnResolve) {
+        console.log(stack.identify());
+      }
+      return handler;
+    }
+  };
+  return stack;
+};
+var stepWeights = {
+  initialize: 5,
+  serialize: 4,
+  build: 3,
+  finalizeRequest: 2,
+  deserialize: 1
+};
+var priorityWeights = {
+  high: 3,
+  normal: 2,
+  low: 1
+};
+
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/client.js
+var Client = class {
+  config;
+  middlewareStack = constructStack();
+  initConfig;
+  handlers;
+  constructor(config) {
+    this.config = config;
+  }
+  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;
+  }
+};
 
-// ../../.yarn/cache/@aws-sdk-middleware-host-header-npm-3.804.0-be68ca7913-4089d24b70.zip/node_modules/@aws-sdk/middleware-host-header/dist-es/index.js
+// ../../.yarn/cache/@smithy-types-npm-4.9.0-93f68e10e2-7068428d2e.zip/node_modules/@smithy/types/dist-es/endpoint.js
+var EndpointURLScheme;
+(function(EndpointURLScheme2) {
+  EndpointURLScheme2["HTTP"] = "http";
+  EndpointURLScheme2["HTTPS"] = "https";
+})(EndpointURLScheme || (EndpointURLScheme = {}));
+
+// ../../.yarn/cache/@smithy-types-npm-4.9.0-93f68e10e2-7068428d2e.zip/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 = {}));
+
+// ../../.yarn/cache/@smithy-types-npm-4.9.0-93f68e10e2-7068428d2e.zip/node_modules/@smithy/types/dist-es/middleware.js
+var SMITHY_CONTEXT_KEY = "__smithy_context";
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/schema/deref.js
+var deref = (schemaRef) => {
+  if (typeof schemaRef === "function") {
+    return schemaRef();
+  }
+  return schemaRef;
+};
+
+// ../../.yarn/cache/@smithy-protocol-http-npm-5.3.5-49ab1bf413-15e6bfbf39.zip/node_modules/@smithy/protocol-http/dist-es/extensions/httpExtensionConfiguration.js
+var getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
+  return {
+    setHttpHandler(handler) {
+      runtimeConfig.httpHandler = handler;
+    },
+    httpHandler() {
+      return runtimeConfig.httpHandler;
+    },
+    updateHttpClientConfig(key, value) {
+      runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
+    },
+    httpHandlerConfigs() {
+      return runtimeConfig.httpHandler.httpHandlerConfigs();
+    }
+  };
+};
+var resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
+  return {
+    httpHandler: httpHandlerExtensionConfiguration.httpHandler()
+  };
+};
+
+// ../../.yarn/cache/@smithy-util-middleware-npm-4.2.5-16e1742a1b-6b05a986ec.zip/node_modules/@smithy/util-middleware/dist-es/getSmithyContext.js
+var getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
+
+// ../../.yarn/cache/@smithy-util-middleware-npm-4.2.5-16e1742a1b-6b05a986ec.zip/node_modules/@smithy/util-middleware/dist-es/normalizeProvider.js
+var normalizeProvider = (input) => {
+  if (typeof input === "function")
+    return input;
+  const promisified = Promise.resolve(input);
+  return () => promisified;
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/schema/schemas/operation.js
+var operation = (namespace, name, traits, input, output) => ({
+  name,
+  namespace,
+  traits,
+  input,
+  output
+});
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js
+var schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
+  const { response } = await next(args);
+  const { operationSchema } = getSmithyContext(context);
+  const [, ns, n, t, i, o] = operationSchema ?? [];
+  try {
+    const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
+      ...config,
+      ...context
+    }, response);
+    return {
+      response,
+      output: parsed
+    };
+  } catch (error) {
+    Object.defineProperty(error, "$response", {
+      value: response,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+    if (!("$metadata" in error)) {
+      const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
+      try {
+        error.message += "\n  " + hint;
+      } catch (e) {
+        if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
+          console.warn(hint);
+        } else {
+          context.logger?.warn?.(hint);
+        }
+      }
+      if (typeof error.$responseBodyText !== "undefined") {
+        if (error.$response) {
+          error.$response.body = error.$responseBodyText;
+        }
+      }
+      try {
+        if (HttpResponse.isInstance(response)) {
+          const { headers = {} } = response;
+          const headerEntries = Object.entries(headers);
+          error.$metadata = {
+            httpStatusCode: response.statusCode,
+            requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
+            extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
+            cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
+          };
+        }
+      } catch (e) {
+      }
+    }
+    throw error;
+  }
+};
+var findHeader = (pattern, headers) => {
+  return (headers.find(([k]) => {
+    return k.match(pattern);
+  }) || [void 0, void 0])[1];
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js
+var schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
+  const { operationSchema } = getSmithyContext(context);
+  const [, ns, n, t, i, o] = operationSchema ?? [];
+  const endpoint = context.endpointV2?.url && config.urlParser ? async () => config.urlParser(context.endpointV2.url) : config.endpoint;
+  const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
+    ...config,
+    ...context,
+    endpoint
+  });
+  return next({
+    ...args,
+    request
+  });
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js
+var deserializerMiddlewareOption = {
+  name: "deserializerMiddleware",
+  step: "deserialize",
+  tags: ["DESERIALIZER"],
+  override: true
+};
+var serializerMiddlewareOption = {
+  name: "serializerMiddleware",
+  step: "serialize",
+  tags: ["SERIALIZER"],
+  override: true
+};
+function getSchemaSerdePlugin(config) {
+  return {
+    applyToStack: (commandStack) => {
+      commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
+      commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
+      config.protocol.setSerdeContext(config);
+    }
+  };
+}
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/schema/schemas/translateTraits.js
+function translateTraits(indicator) {
+  if (typeof indicator === "object") {
+    return indicator;
+  }
+  indicator = indicator | 0;
+  const traits = {};
+  let i = 0;
+  for (const trait of [
+    "httpLabel",
+    "idempotent",
+    "idempotencyToken",
+    "sensitive",
+    "httpPayload",
+    "httpResponseCode",
+    "httpQueryParams"
+  ]) {
+    if ((indicator >> i++ & 1) === 1) {
+      traits[trait] = 1;
+    }
+  }
+  return traits;
+}
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js
+var NormalizedSchema = class _NormalizedSchema {
+  ref;
+  memberName;
+  static symbol = Symbol.for("@smithy/nor");
+  symbol = _NormalizedSchema.symbol;
+  name;
+  schema;
+  _isMemberSchema;
+  traits;
+  memberTraits;
+  normalizedTraits;
+  constructor(ref, memberName) {
+    this.ref = ref;
+    this.memberName = memberName;
+    const traitStack = [];
+    let _ref = ref;
+    let schema = ref;
+    this._isMemberSchema = false;
+    while (isMemberSchema(_ref)) {
+      traitStack.push(_ref[1]);
+      _ref = _ref[0];
+      schema = deref(_ref);
+      this._isMemberSchema = true;
+    }
+    if (traitStack.length > 0) {
+      this.memberTraits = {};
+      for (let i = traitStack.length - 1; i >= 0; --i) {
+        const traitSet = traitStack[i];
+        Object.assign(this.memberTraits, translateTraits(traitSet));
+      }
+    } else {
+      this.memberTraits = 0;
+    }
+    if (schema instanceof _NormalizedSchema) {
+      const computedMemberTraits = this.memberTraits;
+      Object.assign(this, schema);
+      this.memberTraits = Object.assign({}, computedMemberTraits, schema.getMemberTraits(), this.getMemberTraits());
+      this.normalizedTraits = void 0;
+      this.memberName = memberName ?? schema.memberName;
+      return;
+    }
+    this.schema = deref(schema);
+    if (isStaticSchema(this.schema)) {
+      this.name = `${this.schema[1]}#${this.schema[2]}`;
+      this.traits = this.schema[3];
+    } else {
+      this.name = this.memberName ?? String(schema);
+      this.traits = 0;
+    }
+    if (this._isMemberSchema && !memberName) {
+      throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
+    }
+  }
+  static [Symbol.hasInstance](lhs) {
+    const isPrototype = this.prototype.isPrototypeOf(lhs);
+    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
+      const ns = lhs;
+      return ns.symbol === this.symbol;
+    }
+    return isPrototype;
+  }
+  static of(ref) {
+    const sc = deref(ref);
+    if (sc instanceof _NormalizedSchema) {
+      return sc;
+    }
+    if (isMemberSchema(sc)) {
+      const [ns, traits] = sc;
+      if (ns instanceof _NormalizedSchema) {
+        Object.assign(ns.getMergedTraits(), translateTraits(traits));
+        return ns;
+      }
+      throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`);
+    }
+    return new _NormalizedSchema(sc);
+  }
+  getSchema() {
+    const sc = this.schema;
+    if (sc[0] === 0) {
+      return sc[4];
+    }
+    return sc;
+  }
+  getName(withNamespace = false) {
+    const { name } = this;
+    const short = !withNamespace && name && name.includes("#");
+    return short ? name.split("#")[1] : name || void 0;
+  }
+  getMemberName() {
+    return this.memberName;
+  }
+  isMemberSchema() {
+    return this._isMemberSchema;
+  }
+  isListSchema() {
+    const sc = this.getSchema();
+    return typeof sc === "number" ? sc >= 64 && sc < 128 : sc[0] === 1;
+  }
+  isMapSchema() {
+    const sc = this.getSchema();
+    return typeof sc === "number" ? sc >= 128 && sc <= 255 : sc[0] === 2;
+  }
+  isStructSchema() {
+    const sc = this.getSchema();
+    return sc[0] === 3 || sc[0] === -3;
+  }
+  isBlobSchema() {
+    const sc = this.getSchema();
+    return sc === 21 || sc === 42;
+  }
+  isTimestampSchema() {
+    const sc = this.getSchema();
+    return typeof sc === "number" && sc >= 4 && sc <= 7;
+  }
+  isUnitSchema() {
+    return this.getSchema() === "unit";
+  }
+  isDocumentSchema() {
+    return this.getSchema() === 15;
+  }
+  isStringSchema() {
+    return this.getSchema() === 0;
+  }
+  isBooleanSchema() {
+    return this.getSchema() === 2;
+  }
+  isNumericSchema() {
+    return this.getSchema() === 1;
+  }
+  isBigIntegerSchema() {
+    return this.getSchema() === 17;
+  }
+  isBigDecimalSchema() {
+    return this.getSchema() === 19;
+  }
+  isStreaming() {
+    const { streaming } = this.getMergedTraits();
+    return !!streaming || this.getSchema() === 42;
+  }
+  isIdempotencyToken() {
+    const match = (traits2) => (traits2 & 4) === 4 || !!traits2?.idempotencyToken;
+    const { normalizedTraits, traits, memberTraits } = this;
+    return match(normalizedTraits) || match(traits) || match(memberTraits);
+  }
+  getMergedTraits() {
+    return this.normalizedTraits ?? (this.normalizedTraits = {
+      ...this.getOwnTraits(),
+      ...this.getMemberTraits()
+    });
+  }
+  getMemberTraits() {
+    return translateTraits(this.memberTraits);
+  }
+  getOwnTraits() {
+    return translateTraits(this.traits);
+  }
+  getKeySchema() {
+    const [isDoc, isMap] = [this.isDocumentSchema(), this.isMapSchema()];
+    if (!isDoc && !isMap) {
+      throw new Error(`@smithy/core/schema - cannot get key for non-map: ${this.getName(true)}`);
+    }
+    const schema = this.getSchema();
+    const memberSchema = isDoc ? 15 : schema[4] ?? 0;
+    return member([memberSchema, 0], "key");
+  }
+  getValueSchema() {
+    const sc = this.getSchema();
+    const [isDoc, isMap, isList] = [this.isDocumentSchema(), this.isMapSchema(), this.isListSchema()];
+    const memberSchema = typeof sc === "number" ? 63 & sc : sc && typeof sc === "object" && (isMap || isList) ? sc[3 + sc[0]] : isDoc ? 15 : void 0;
+    if (memberSchema != null) {
+      return member([memberSchema, 0], isMap ? "value" : "member");
+    }
+    throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`);
+  }
+  getMemberSchema(memberName) {
+    const struct = this.getSchema();
+    if (this.isStructSchema() && struct[4].includes(memberName)) {
+      const i = struct[4].indexOf(memberName);
+      const memberSchema = struct[5][i];
+      return member(isMemberSchema(memberSchema) ? memberSchema : [memberSchema, 0], memberName);
+    }
+    if (this.isDocumentSchema()) {
+      return member([15, 0], memberName);
+    }
+    throw new Error(`@smithy/core/schema - ${this.getName(true)} has no no member=${memberName}.`);
+  }
+  getMemberSchemas() {
+    const buffer = {};
+    try {
+      for (const [k, v] of this.structIterator()) {
+        buffer[k] = v;
+      }
+    } catch (ignored) {
+    }
+    return buffer;
+  }
+  getEventStreamMember() {
+    if (this.isStructSchema()) {
+      for (const [memberName, memberSchema] of this.structIterator()) {
+        if (memberSchema.isStreaming() && memberSchema.isStructSchema()) {
+          return memberName;
+        }
+      }
+    }
+    return "";
+  }
+  *structIterator() {
+    if (this.isUnitSchema()) {
+      return;
+    }
+    if (!this.isStructSchema()) {
+      throw new Error("@smithy/core/schema - cannot iterate non-struct schema.");
+    }
+    const struct = this.getSchema();
+    for (let i = 0; i < struct[4].length; ++i) {
+      yield [struct[4][i], member([struct[5][i], 0], struct[4][i])];
+    }
+  }
+};
+function member(memberSchema, memberName) {
+  if (memberSchema instanceof NormalizedSchema) {
+    return Object.assign(memberSchema, {
+      memberName,
+      _isMemberSchema: true
+    });
+  }
+  const internalCtorAccess = NormalizedSchema;
+  return new internalCtorAccess(memberSchema, memberName);
+}
+var isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
+var isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js
+var TypeRegistry = class _TypeRegistry {
+  namespace;
+  schemas;
+  exceptions;
+  static registries = /* @__PURE__ */ new Map();
+  constructor(namespace, schemas = /* @__PURE__ */ new Map(), exceptions = /* @__PURE__ */ new Map()) {
+    this.namespace = namespace;
+    this.schemas = schemas;
+    this.exceptions = exceptions;
+  }
+  static for(namespace) {
+    if (!_TypeRegistry.registries.has(namespace)) {
+      _TypeRegistry.registries.set(namespace, new _TypeRegistry(namespace));
+    }
+    return _TypeRegistry.registries.get(namespace);
+  }
+  register(shapeId, schema) {
+    const qualifiedName = this.normalizeShapeId(shapeId);
+    const registry = _TypeRegistry.for(qualifiedName.split("#")[0]);
+    registry.schemas.set(qualifiedName, schema);
+  }
+  getSchema(shapeId) {
+    const id = this.normalizeShapeId(shapeId);
+    if (!this.schemas.has(id)) {
+      throw new Error(`@smithy/core/schema - schema not found for ${id}`);
+    }
+    return this.schemas.get(id);
+  }
+  registerError(es, ctor) {
+    const $error = es;
+    const registry = _TypeRegistry.for($error[1]);
+    registry.schemas.set($error[1] + "#" + $error[2], $error);
+    registry.exceptions.set($error, ctor);
+  }
+  getErrorCtor(es) {
+    const $error = es;
+    const registry = _TypeRegistry.for($error[1]);
+    return registry.exceptions.get($error);
+  }
+  getBaseException() {
+    for (const exceptionKey of this.exceptions.keys()) {
+      if (Array.isArray(exceptionKey)) {
+        const [, ns, name] = exceptionKey;
+        const id = ns + "#" + name;
+        if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
+          return exceptionKey;
+        }
+      }
+    }
+    return void 0;
+  }
+  find(predicate) {
+    return [...this.schemas.values()].find(predicate);
+  }
+  clear() {
+    this.schemas.clear();
+    this.exceptions.clear();
+  }
+  normalizeShapeId(shapeId) {
+    if (shapeId.includes("#")) {
+      return shapeId;
+    }
+    return this.namespace + "#" + shapeId;
+  }
+};
+
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/schemaLogFilter.js
+var SENSITIVE_STRING = "***SensitiveInformation***";
+function schemaLogFilter(schema, data) {
+  if (data == null) {
+    return data;
+  }
+  const ns = NormalizedSchema.of(schema);
+  if (ns.getMergedTraits().sensitive) {
+    return SENSITIVE_STRING;
+  }
+  if (ns.isListSchema()) {
+    const isSensitive = !!ns.getValueSchema().getMergedTraits().sensitive;
+    if (isSensitive) {
+      return SENSITIVE_STRING;
+    }
+  } else if (ns.isMapSchema()) {
+    const isSensitive = !!ns.getKeySchema().getMergedTraits().sensitive || !!ns.getValueSchema().getMergedTraits().sensitive;
+    if (isSensitive) {
+      return SENSITIVE_STRING;
+    }
+  } else if (ns.isStructSchema() && typeof data === "object") {
+    const object = data;
+    const newObject = {};
+    for (const [member2, memberNs] of ns.structIterator()) {
+      if (object[member2] != null) {
+        newObject[member2] = schemaLogFilter(memberNs, object[member2]);
+      }
+    }
+    return newObject;
+  }
+  return data;
+}
+
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/command.js
+var Command = class {
+  middlewareStack = constructStack();
+  schema;
+  static classBuilder() {
+    return new ClassBuilder();
+  }
+  resolveMiddlewareWithContext(clientStack, configuration, options, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor }) {
+    for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) {
+      this.middlewareStack.use(mw);
+    }
+    const stack = clientStack.concat(this.middlewareStack);
+    const { logger } = configuration;
+    const handlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog,
+      outputFilterSensitiveLog,
+      [SMITHY_CONTEXT_KEY]: {
+        commandInstance: this,
+        ...smithyContext
+      },
+      ...additionalContext
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+  }
+};
+var ClassBuilder = class {
+  _init = () => {
+  };
+  _ep = {};
+  _middlewareFn = () => [];
+  _commandName = "";
+  _clientName = "";
+  _additionalContext = {};
+  _smithyContext = {};
+  _inputFilterSensitiveLog = void 0;
+  _outputFilterSensitiveLog = void 0;
+  _serializer = null;
+  _deserializer = null;
+  _operationSchema;
+  init(cb) {
+    this._init = cb;
+  }
+  ep(endpointParameterInstructions) {
+    this._ep = endpointParameterInstructions;
+    return this;
+  }
+  m(middlewareSupplier) {
+    this._middlewareFn = middlewareSupplier;
+    return this;
+  }
+  s(service, operation2, smithyContext = {}) {
+    this._smithyContext = {
+      service,
+      operation: operation2,
+      ...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(operation2) {
+    this._operationSchema = operation2;
+    this._smithyContext.operationSchema = operation2;
+    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;
+    };
+  }
+};
+
+// ../../.yarn/cache/@aws-sdk-middleware-host-header-npm-3.936.0-9da9f6f22b-524221650f.zip/node_modules/@aws-sdk/middleware-host-header/dist-es/index.js
 function resolveHostHeaderConfig(input) {
   return input;
 }
@@ -63,7 +1019,7 @@ var getHostHeaderPlugin = (options) => ({
   }
 });
 
-// ../../.yarn/cache/@aws-sdk-middleware-logger-npm-3.804.0-a7b86f3ea1-4b7deebb33.zip/node_modules/@aws-sdk/middleware-logger/dist-es/loggerMiddleware.js
+// ../../.yarn/cache/@aws-sdk-middleware-logger-npm-3.936.0-f4dd2ddeff-9f94ae2f30.zip/node_modules/@aws-sdk/middleware-logger/dist-es/loggerMiddleware.js
 var loggerMiddleware = () => (next, context) => async (args) => {
   try {
     const response = await next(args);
@@ -106,13 +1062,137 @@ var getLoggerPlugin = (options) => ({
   }
 });
 
-// ../../.yarn/cache/@aws-sdk-middleware-recursion-detection-npm-3.804.0-4c5a442f7f-86e6d2902d.zip/node_modules/@aws-sdk/middleware-recursion-detection/dist-es/index.js
+// ../../.yarn/cache/@aws-sdk-middleware-recursion-detection-npm-3.936.0-d27306c983-3230f48688.zip/node_modules/@aws-sdk/middleware-recursion-detection/dist-es/configuration.js
+var recursionDetectionMiddlewareOptions = {
+  step: "build",
+  tags: ["RECURSION_DETECTION"],
+  name: "recursionDetectionMiddleware",
+  override: true,
+  priority: "low"
+};
+
+// ../../.yarn/cache/@aws-lambda-invoke-store-npm-0.2.1-93a949e0eb-7fdfd6e4b1.zip/node_modules/@aws/lambda-invoke-store/dist-es/invoke-store.js
+var PROTECTED_KEYS = {
+  REQUEST_ID: Symbol.for("_AWS_LAMBDA_REQUEST_ID"),
+  X_RAY_TRACE_ID: Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"),
+  TENANT_ID: 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;
+    try {
+      return fn();
+    } finally {
+      this.currentContext = void 0;
+    }
+  }
+};
+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() {
+    if (!instance) {
+      instance = (async () => {
+        const isMulti = "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 = {};
+    }
+  } : void 0;
+})(InvokeStore || (InvokeStore = {}));
+
+// ../../.yarn/cache/@aws-sdk-middleware-recursion-detection-npm-3.936.0-d27306c983-3230f48688.zip/node_modules/@aws-sdk/middleware-recursion-detection/dist-es/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 = (options) => (next) => async (args) => {
+var recursionDetectionMiddleware = () => (next) => async (args) => {
   const { request } = args;
-  if (!HttpRequest.isInstance(request) || options.runtime !== "node") {
+  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;
@@ -120,7 +1200,10 @@ var recursionDetectionMiddleware = (options) => (next) => async (args) => {
     return next(args);
   }
   const functionName = process.env[ENV_LAMBDA_FUNCTION_NAME];
-  const traceId = process.env[ENV_TRACE_ID];
+  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;
@@ -130,31 +1213,15 @@ var recursionDetectionMiddleware = (options) => (next) => async (args) => {
     request
   });
 };
-var addRecursionDetectionMiddlewareOptions = {
-  step: "build",
-  tags: ["RECURSION_DETECTION"],
-  name: "recursionDetectionMiddleware",
-  override: true,
-  priority: "low"
-};
+
+// ../../.yarn/cache/@aws-sdk-middleware-recursion-detection-npm-3.936.0-d27306c983-3230f48688.zip/node_modules/@aws-sdk/middleware-recursion-detection/dist-es/getRecursionDetectionPlugin.js
 var getRecursionDetectionPlugin = (options) => ({
   applyToStack: (clientStack) => {
-    clientStack.add(recursionDetectionMiddleware(options), addRecursionDetectionMiddlewareOptions);
+    clientStack.add(recursionDetectionMiddleware(), recursionDetectionMiddlewareOptions);
   }
 });
 
-// ../../.yarn/cache/@smithy-util-middleware-npm-4.0.3-f7250b67f0-c9de70875c.zip/node_modules/@smithy/util-middleware/dist-es/getSmithyContext.js
-var getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
-
-// ../../.yarn/cache/@smithy-util-middleware-npm-4.0.3-f7250b67f0-c9de70875c.zip/node_modules/@smithy/util-middleware/dist-es/normalizeProvider.js
-var normalizeProvider = (input) => {
-  if (typeof input === "function")
-    return input;
-  const promisified = Promise.resolve(input);
-  return () => promisified;
-};
-
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/resolveAuthOptions.js
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/resolveAuthOptions.js
 var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
   if (!authSchemePreference || authSchemePreference.length === 0) {
     return candidateAuthOptions;
@@ -176,7 +1243,7 @@ var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
   return preferredAuthOptions;
 };
 
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js
 function convertHttpAuthSchemesToMap(httpAuthSchemes) {
   const map = /* @__PURE__ */ new Map();
   for (const scheme of httpAuthSchemes) {
@@ -218,7 +1285,7 @@ var httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (
   return next(args);
 };
 
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.js
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.js
 var httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
   step: "serialize",
   tags: ["HTTP_AUTH_SCHEME"],
@@ -236,95 +1303,7 @@ var getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParameters
   }
 });
 
-// ../../.yarn/cache/@smithy-middleware-serde-npm-4.0.6-63cfd55ed4-c99d872d2c.zip/node_modules/@smithy/middleware-serde/dist-es/deserializerMiddleware.js
-var deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
-  const { response } = await next(args);
-  try {
-    const parsed = await deserializer(response, options);
-    return {
-      response,
-      output: parsed
-    };
-  } catch (error) {
-    Object.defineProperty(error, "$response", {
-      value: response
-    });
-    if (!("$metadata" in error)) {
-      const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
-      try {
-        error.message += "\n  " + hint;
-      } catch (e) {
-        if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
-          console.warn(hint);
-        } else {
-          context.logger?.warn?.(hint);
-        }
-      }
-      if (typeof error.$responseBodyText !== "undefined") {
-        if (error.$response) {
-          error.$response.body = error.$responseBodyText;
-        }
-      }
-      try {
-        if (HttpResponse.isInstance(response)) {
-          const { headers = {} } = response;
-          const headerEntries = Object.entries(headers);
-          error.$metadata = {
-            httpStatusCode: response.statusCode,
-            requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
-            extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
-            cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
-          };
-        }
-      } catch (e) {
-      }
-    }
-    throw error;
-  }
-};
-var findHeader = (pattern, headers) => {
-  return (headers.find(([k]) => {
-    return k.match(pattern);
-  }) || [void 0, void 0])[1];
-};
-
-// ../../.yarn/cache/@smithy-middleware-serde-npm-4.0.6-63cfd55ed4-c99d872d2c.zip/node_modules/@smithy/middleware-serde/dist-es/serializerMiddleware.js
-var serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
-  const endpointConfig = options;
-  const endpoint = context.endpointV2?.url && endpointConfig.urlParser ? async () => endpointConfig.urlParser(context.endpointV2.url) : endpointConfig.endpoint;
-  if (!endpoint) {
-    throw new Error("No valid endpoint provider available.");
-  }
-  const request = await serializer(args.input, { ...options, endpoint });
-  return next({
-    ...args,
-    request
-  });
-};
-
-// ../../.yarn/cache/@smithy-middleware-serde-npm-4.0.6-63cfd55ed4-c99d872d2c.zip/node_modules/@smithy/middleware-serde/dist-es/serdePlugin.js
-var deserializerMiddlewareOption = {
-  name: "deserializerMiddleware",
-  step: "deserialize",
-  tags: ["DESERIALIZER"],
-  override: true
-};
-var serializerMiddlewareOption = {
-  name: "serializerMiddleware",
-  step: "serialize",
-  tags: ["SERIALIZER"],
-  override: true
-};
-function getSerdePlugin(config, serializer, deserializer) {
-  return {
-    applyToStack: (commandStack) => {
-      commandStack.add(deserializerMiddleware(config, deserializer), deserializerMiddlewareOption);
-      commandStack.add(serializerMiddleware(config, serializer), serializerMiddlewareOption);
-    }
-  };
-}
-
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/middleware-http-signing/httpSigningMiddleware.js
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/middleware-http-signing/httpSigningMiddleware.js
 var defaultErrorHandler = (signingProperties) => (error) => {
   throw error;
 };
@@ -348,7 +1327,7 @@ var httpSigningMiddleware = (config) => (next, context) => async (args) => {
   return output;
 };
 
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/middleware-http-signing/getHttpSigningMiddleware.js
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/middleware-http-signing/getHttpSigningMiddleware.js
 var httpSigningMiddlewareOptions = {
   step: "finalizeRequest",
   tags: ["HTTP_SIGNING"],
@@ -364,10 +1343,10 @@ var getHttpSigningPlugin = (config) => ({
   }
 });
 
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/util-identity-and-auth/DefaultIdentityProviderConfig.js
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/util-identity-and-auth/DefaultIdentityProviderConfig.js
 var DefaultIdentityProviderConfig = class {
+  authSchemes = /* @__PURE__ */ new Map();
   constructor(config) {
-    this.authSchemes = /* @__PURE__ */ new Map();
     for (const [key, value] of Object.entries(config)) {
       if (value !== void 0) {
         this.authSchemes.set(key, value);
@@ -379,17 +1358,15 @@ var DefaultIdentityProviderConfig = class {
   }
 };
 
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/getHttpAuthSchemePlugin.js
-var httpAuthSchemeMiddlewareOptions = {
+// ../../.yarn/cache/@smithy-middleware-serde-npm-4.2.6-44dd6e9fd7-c7b4f806f3.zip/node_modules/@smithy/middleware-serde/dist-es/serdePlugin.js
+var serializerMiddlewareOption2 = {
+  name: "serializerMiddleware",
   step: "serialize",
-  tags: ["HTTP_AUTH_SCHEME"],
-  name: "httpAuthSchemeMiddleware",
-  override: true,
-  relation: "before",
-  toMiddleware: serializerMiddlewareOption.name
+  tags: ["SERIALIZER"],
+  override: true
 };
 
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/normalizeProvider.js
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/normalizeProvider.js
 var normalizeProvider2 = (input) => {
   if (typeof input === "function")
     return input;
@@ -397,7 +1374,466 @@ var normalizeProvider2 = (input) => {
   return () => promisified;
 };
 
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/setFeature.js
+// ../../.yarn/cache/@smithy-util-utf8-npm-4.2.0-129dbf931f-689a1f2295.zip/node_modules/@smithy/util-utf8/dist-es/toUint8Array.js
+var toUint8Array = (data) => {
+  if (typeof data === "string") {
+    return fromUtf8(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+  }
+  return new Uint8Array(data);
+};
+
+// ../../.yarn/cache/@smithy-util-stream-npm-4.5.6-2962292a4c-42bb6f834b.zip/node_modules/@smithy/util-stream/dist-es/blob/Uint8ArrayBlobAdapter.js
+var Uint8ArrayBlobAdapter = class _Uint8ArrayBlobAdapter extends Uint8Array {
+  static fromString(source, encoding = "utf-8") {
+    if (typeof source === "string") {
+      if (encoding === "base64") {
+        return _Uint8ArrayBlobAdapter.mutate(fromBase64(source));
+      }
+      return _Uint8ArrayBlobAdapter.mutate(fromUtf8(source));
+    }
+    throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+  }
+  static mutate(source) {
+    Object.setPrototypeOf(source, _Uint8ArrayBlobAdapter.prototype);
+    return source;
+  }
+  transformToString(encoding = "utf-8") {
+    if (encoding === "base64") {
+      return toBase64(this);
+    }
+    return toUtf8(this);
+  }
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/protocols/collect-stream-body.js
+var collectBody = async (streamBody = new Uint8Array(), context) => {
+  if (streamBody instanceof Uint8Array) {
+    return Uint8ArrayBlobAdapter.mutate(streamBody);
+  }
+  if (!streamBody) {
+    return Uint8ArrayBlobAdapter.mutate(new Uint8Array());
+  }
+  const fromContext = context.streamCollector(streamBody);
+  return Uint8ArrayBlobAdapter.mutate(await fromContext);
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/protocols/extended-encode-uri-component.js
+function extendedEncodeURIComponent(str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+  });
+}
+
+// ../../.yarn/cache/@smithy-uuid-npm-1.1.0-c3c39c12ad-f8a8bfcc0e.zip/node_modules/@smithy/uuid/dist-es/randomUUID.js
+import crypto2 from "crypto";
+var randomUUID = crypto2.randomUUID.bind(crypto2);
+
+// ../../.yarn/cache/@smithy-uuid-npm-1.1.0-c3c39c12ad-f8a8bfcc0e.zip/node_modules/@smithy/uuid/dist-es/v4.js
+var decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+var v4 = () => {
+  if (randomUUID) {
+    return randomUUID();
+  }
+  const rnds = new Uint8Array(16);
+  crypto.getRandomValues(rnds);
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  return decimalToHex[rnds[0]] + decimalToHex[rnds[1]] + decimalToHex[rnds[2]] + decimalToHex[rnds[3]] + "-" + decimalToHex[rnds[4]] + decimalToHex[rnds[5]] + "-" + decimalToHex[rnds[6]] + decimalToHex[rnds[7]] + "-" + decimalToHex[rnds[8]] + decimalToHex[rnds[9]] + "-" + decimalToHex[rnds[10]] + decimalToHex[rnds[11]] + decimalToHex[rnds[12]] + decimalToHex[rnds[13]] + decimalToHex[rnds[14]] + decimalToHex[rnds[15]];
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/serde/lazy-json.js
+var LazyJsonString = function LazyJsonString2(val) {
+  const str = Object.assign(new String(val), {
+    deserializeJSON() {
+      return JSON.parse(String(val));
+    },
+    toString() {
+      return String(val);
+    },
+    toJSON() {
+      return String(val);
+    }
+  });
+  return str;
+};
+LazyJsonString.from = (object) => {
+  if (object && typeof object === "object" && (object instanceof LazyJsonString || "deserializeJSON" in object)) {
+    return object;
+  } else if (typeof object === "string" || Object.getPrototypeOf(object) === String.prototype) {
+    return LazyJsonString(String(object));
+  }
+  return LazyJsonString(JSON.stringify(object));
+};
+LazyJsonString.fromObject = LazyJsonString.from;
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/serde/schema-serde-lib/schema-date-utils.js
+var ddd = `(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)(?:[ne|u?r]?s?day)?`;
+var mmm = `(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)`;
+var time = `(\\d?\\d):(\\d{2}):(\\d{2})(?:\\.(\\d+))?`;
+var date = `(\\d?\\d)`;
+var year = `(\\d{4})`;
+var RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d\d)-(\d\d)[tT](\d\d):(\d\d):(\d\d)(\.(\d+))?(([-+]\d\d:\d\d)|[zZ])$/);
+var IMF_FIXDATE = new RegExp(`^${ddd}, ${date} ${mmm} ${year} ${time} GMT$`);
+var RFC_850_DATE = new RegExp(`^${ddd}, ${date}-${mmm}-(\\d\\d) ${time} GMT$`);
+var ASC_TIME = new RegExp(`^${ddd} ${mmm} ( [1-9]|\\d\\d) ${time} ${year}$`);
+var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var _parseEpochTimestamp = (value) => {
+  if (value == null) {
+    return void 0;
+  }
+  let num = NaN;
+  if (typeof value === "number") {
+    num = value;
+  } else if (typeof value === "string") {
+    if (!/^-?\d*\.?\d+$/.test(value)) {
+      throw new TypeError(`parseEpochTimestamp - numeric string invalid.`);
+    }
+    num = Number.parseFloat(value);
+  } else if (typeof value === "object" && value.tag === 1) {
+    num = value.value;
+  }
+  if (isNaN(num) || Math.abs(num) === Infinity) {
+    throw new TypeError("Epoch timestamps must be valid finite numbers.");
+  }
+  return new Date(Math.round(num * 1e3));
+};
+var _parseRfc3339DateTimeWithOffset = (value) => {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC3339 timestamps must be strings");
+  }
+  const matches = RFC3339_WITH_OFFSET.exec(value);
+  if (!matches) {
+    throw new TypeError(`Invalid RFC3339 timestamp format ${value}`);
+  }
+  const [, yearStr, monthStr, dayStr, hours, minutes, seconds, , ms, offsetStr] = matches;
+  range(monthStr, 1, 12);
+  range(dayStr, 1, 31);
+  range(hours, 0, 23);
+  range(minutes, 0, 59);
+  range(seconds, 0, 60);
+  const date2 = new Date(Date.UTC(Number(yearStr), Number(monthStr) - 1, Number(dayStr), Number(hours), Number(minutes), Number(seconds), Number(ms) ? Math.round(parseFloat(`0.${ms}`) * 1e3) : 0));
+  date2.setUTCFullYear(Number(yearStr));
+  if (offsetStr.toUpperCase() != "Z") {
+    const [, sign, offsetH, offsetM] = /([+-])(\d\d):(\d\d)/.exec(offsetStr) || [void 0, "+", 0, 0];
+    const scalar = sign === "-" ? 1 : -1;
+    date2.setTime(date2.getTime() + scalar * (Number(offsetH) * 60 * 60 * 1e3 + Number(offsetM) * 60 * 1e3));
+  }
+  return date2;
+};
+var _parseRfc7231DateTime = (value) => {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC7231 timestamps must be strings.");
+  }
+  let day;
+  let month;
+  let year2;
+  let hour;
+  let minute;
+  let second;
+  let fraction;
+  let matches;
+  if (matches = IMF_FIXDATE.exec(value)) {
+    [, day, month, year2, hour, minute, second, fraction] = matches;
+  } else if (matches = RFC_850_DATE.exec(value)) {
+    [, day, month, year2, hour, minute, second, fraction] = matches;
+    year2 = (Number(year2) + 1900).toString();
+  } else if (matches = ASC_TIME.exec(value)) {
+    [, month, day, hour, minute, second, fraction, year2] = matches;
+  }
+  if (year2 && second) {
+    const timestamp = Date.UTC(Number(year2), months.indexOf(month), Number(day), Number(hour), Number(minute), Number(second), fraction ? Math.round(parseFloat(`0.${fraction}`) * 1e3) : 0);
+    range(day, 1, 31);
+    range(hour, 0, 23);
+    range(minute, 0, 59);
+    range(second, 0, 60);
+    const date2 = new Date(timestamp);
+    date2.setUTCFullYear(Number(year2));
+    return date2;
+  }
+  throw new TypeError(`Invalid RFC7231 date-time value ${value}.`);
+};
+function range(v, min, max) {
+  const _v = Number(v);
+  if (_v < min || _v > max) {
+    throw new Error(`Value ${_v} out of range [${min}, ${max}]`);
+  }
+}
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/serde/split-header.js
+var splitHeader = (value) => {
+  const z = value.length;
+  const values = [];
+  let withinQuotes = false;
+  let prevChar = void 0;
+  let anchor = 0;
+  for (let i = 0; i < z; ++i) {
+    const char = value[i];
+    switch (char) {
+      case `"`:
+        if (prevChar !== "\\") {
+          withinQuotes = !withinQuotes;
+        }
+        break;
+      case ",":
+        if (!withinQuotes) {
+          values.push(value.slice(anchor, i));
+          anchor = i + 1;
+        }
+        break;
+      default:
+    }
+    prevChar = char;
+  }
+  values.push(value.slice(anchor));
+  return values.map((v) => {
+    v = v.trim();
+    const z2 = v.length;
+    if (z2 < 2) {
+      return v;
+    }
+    if (v[0] === `"` && v[z2 - 1] === `"`) {
+      v = v.slice(1, z2 - 1);
+    }
+    return v.replace(/\\"/g, '"');
+  });
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js
+var format = /^-?\d*(\.\d+)?$/;
+var NumericValue = class _NumericValue {
+  string;
+  type;
+  constructor(string, type) {
+    this.string = string;
+    this.type = type;
+    if (!format.test(string)) {
+      throw new Error(`@smithy/core/serde - NumericValue must only contain [0-9], at most one decimal point ".", and an optional negation prefix "-".`);
+    }
+  }
+  toString() {
+    return this.string;
+  }
+  static [Symbol.hasInstance](object) {
+    if (!object || typeof object !== "object") {
+      return false;
+    }
+    const _nv = object;
+    return _NumericValue.prototype.isPrototypeOf(object) || _nv.type === "bigDecimal" && format.test(_nv.string);
+  }
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/protocols/SerdeContext.js
+var SerdeContext = class {
+  serdeContext;
+  setSerdeContext(serdeContext) {
+    this.serdeContext = serdeContext;
+  }
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js
+var HttpProtocol = class extends SerdeContext {
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  getRequestType() {
+    return HttpRequest;
+  }
+  getResponseType() {
+    return HttpResponse;
+  }
+  setSerdeContext(serdeContext) {
+    this.serdeContext = serdeContext;
+    this.serializer.setSerdeContext(serdeContext);
+    this.deserializer.setSerdeContext(serdeContext);
+    if (this.getPayloadCodec()) {
+      this.getPayloadCodec().setSerdeContext(serdeContext);
+    }
+  }
+  updateServiceEndpoint(request, endpoint) {
+    if ("url" in endpoint) {
+      request.protocol = endpoint.url.protocol;
+      request.hostname = endpoint.url.hostname;
+      request.port = endpoint.url.port ? Number(endpoint.url.port) : void 0;
+      request.path = endpoint.url.pathname;
+      request.fragment = endpoint.url.hash || void 0;
+      request.username = endpoint.url.username || void 0;
+      request.password = endpoint.url.password || void 0;
+      if (!request.query) {
+        request.query = {};
+      }
+      for (const [k, v] of endpoint.url.searchParams.entries()) {
+        request.query[k] = v;
+      }
+      return request;
+    } else {
+      request.protocol = endpoint.protocol;
+      request.hostname = endpoint.hostname;
+      request.port = endpoint.port ? Number(endpoint.port) : void 0;
+      request.path = endpoint.path;
+      request.query = {
+        ...endpoint.query
+      };
+      return request;
+    }
+  }
+  setHostPrefix(request, operationSchema, input) {
+    const inputNs = NormalizedSchema.of(operationSchema.input);
+    const opTraits = translateTraits(operationSchema.traits ?? {});
+    if (opTraits.endpoint) {
+      let hostPrefix = opTraits.endpoint?.[0];
+      if (typeof hostPrefix === "string") {
+        const hostLabelInputs = [...inputNs.structIterator()].filter(([, member2]) => member2.getMergedTraits().hostLabel);
+        for (const [name] of hostLabelInputs) {
+          const replacement = input[name];
+          if (typeof replacement !== "string") {
+            throw new Error(`@smithy/core/schema - ${name} in input must be a string as hostLabel.`);
+          }
+          hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
+        }
+        request.hostname = hostPrefix + request.hostname;
+      }
+    }
+  }
+  deserializeMetadata(output) {
+    return {
+      httpStatusCode: output.statusCode,
+      requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+      extendedRequestId: output.headers["x-amz-id-2"],
+      cfId: output.headers["x-amz-cf-id"]
+    };
+  }
+  async serializeEventStream({ eventStream, requestSchema, initialRequest }) {
+    const eventStreamSerde = await this.loadEventStreamCapability();
+    return eventStreamSerde.serializeEventStream({
+      eventStream,
+      requestSchema,
+      initialRequest
+    });
+  }
+  async deserializeEventStream({ response, responseSchema, initialResponseContainer }) {
+    const eventStreamSerde = await this.loadEventStreamCapability();
+    return eventStreamSerde.deserializeEventStream({
+      response,
+      responseSchema,
+      initialResponseContainer
+    });
+  }
+  async loadEventStreamCapability() {
+    const { EventStreamSerde } = await import("./event-streams-NGUY2RWE.js");
+    return new EventStreamSerde({
+      marshaller: this.getEventStreamMarshaller(),
+      serializer: this.serializer,
+      deserializer: this.deserializer,
+      serdeContext: this.serdeContext,
+      defaultContentType: this.getDefaultContentType()
+    });
+  }
+  getDefaultContentType() {
+    throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
+  }
+  async deserializeHttpMessage(schema, context, response, arg4, arg5) {
+    void schema;
+    void context;
+    void response;
+    void arg4;
+    void arg5;
+    return [];
+  }
+  getEventStreamMarshaller() {
+    const context = this.serdeContext;
+    if (!context.eventStreamMarshaller) {
+      throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
+    }
+    return context.eventStreamMarshaller;
+  }
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/protocols/serde/determineTimestampFormat.js
+function determineTimestampFormat(ns, settings) {
+  if (settings.timestampFormat.useTrait) {
+    if (ns.isTimestampSchema() && (ns.getSchema() === 5 || ns.getSchema() === 6 || ns.getSchema() === 7)) {
+      return ns.getSchema();
+    }
+  }
+  const { httpLabel, httpPrefixHeaders, httpHeader, httpQuery } = ns.getMergedTraits();
+  const bindingFormat = settings.httpBindings ? typeof httpPrefixHeaders === "string" || Boolean(httpHeader) ? 6 : Boolean(httpQuery) || Boolean(httpLabel) ? 5 : void 0 : void 0;
+  return bindingFormat ?? settings.timestampFormat.default;
+}
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/submodules/protocols/serde/FromStringShapeDeserializer.js
+var FromStringShapeDeserializer = class extends SerdeContext {
+  settings;
+  constructor(settings) {
+    super();
+    this.settings = settings;
+  }
+  read(_schema, data) {
+    const ns = NormalizedSchema.of(_schema);
+    if (ns.isListSchema()) {
+      return splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
+    }
+    if (ns.isBlobSchema()) {
+      return (this.serdeContext?.base64Decoder ?? fromBase64)(data);
+    }
+    if (ns.isTimestampSchema()) {
+      const format2 = determineTimestampFormat(ns, this.settings);
+      switch (format2) {
+        case 5:
+          return _parseRfc3339DateTimeWithOffset(data);
+        case 6:
+          return _parseRfc7231DateTime(data);
+        case 7:
+          return _parseEpochTimestamp(data);
+        default:
+          console.warn("Missing timestamp format, parsing value with Date constructor:", data);
+          return new Date(data);
+      }
+    }
+    if (ns.isStringSchema()) {
+      const mediaType = ns.getMergedTraits().mediaType;
+      let intermediateValue = data;
+      if (mediaType) {
+        if (ns.getMergedTraits().httpHeader) {
+          intermediateValue = this.base64ToUtf8(intermediateValue);
+        }
+        const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
+        if (isJson) {
+          intermediateValue = LazyJsonString.from(intermediateValue);
+        }
+        return intermediateValue;
+      }
+    }
+    if (ns.isNumericSchema()) {
+      return Number(data);
+    }
+    if (ns.isBigIntegerSchema()) {
+      return BigInt(data);
+    }
+    if (ns.isBigDecimalSchema()) {
+      return new NumericValue(data, "bigDecimal");
+    }
+    if (ns.isBooleanSchema()) {
+      return String(data).toLowerCase() === "true";
+    }
+    return data;
+  }
+  base64ToUtf8(base64String) {
+    return (this.serdeContext?.utf8Encoder ?? toUtf8)((this.serdeContext?.base64Decoder ?? fromBase64)(base64String));
+  }
+};
+
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/setFeature.js
 function setFeature(context, feature, value) {
   if (!context.__smithy_context) {
     context.__smithy_context = {
@@ -409,15 +1845,10 @@ function setFeature(context, feature, value) {
   context.__smithy_context.features[feature] = value;
 }
 
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/noAuth.js
-var NoAuthSigner = class {
-  async sign(httpRequest, identity, signingProperties) {
-    return httpRequest;
-  }
+// ../../.yarn/cache/@smithy-core-npm-3.18.5-16e80a170e-c6ccaf4a06.zip/node_modules/@smithy/core/dist-es/util-identity-and-auth/memoizeIdentityProvider.js
+var createIsIdentityExpiredFunction = (expirationMs) => function isIdentityExpired2(identity) {
+  return doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
 };
-
-// ../../.yarn/cache/@smithy-core-npm-3.4.0-638c63a3b8-49b81ea502.zip/node_modules/@smithy/core/dist-es/util-identity-and-auth/memoizeIdentityProvider.js
-var createIsIdentityExpiredFunction = (expirationMs) => (identity) => doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
 var EXPIRATION_MS = 3e5;
 var isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
 var doesIdentityRequireRefresh = (identity) => identity.expiration !== void 0;
@@ -470,7 +1901,7 @@ var memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
   };
 };
 
-// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.816.0-e8bdacf6e2-af3caa6df1.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/configurations.js
+// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.940.0-3e822100ad-1756e35c96.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/configurations.js
 var DEFAULT_UA_APP_ID = void 0;
 function isValidUserAgentAppId(appId) {
   if (appId === void 0) {
@@ -498,11 +1929,59 @@ function resolveUserAgentConfig(input) {
   });
 }
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/cache/EndpointCache.js
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/exceptions.js
+var ServiceException = class _ServiceException extends Error {
+  $fault;
+  $response;
+  $retryable;
+  $metadata;
+  constructor(options) {
+    super(options.message);
+    Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
+    this.name = options.name;
+    this.$fault = options.$fault;
+    this.$metadata = options.$metadata;
+  }
+  static isInstance(value) {
+    if (!value)
+      return false;
+    const candidate = value;
+    return _ServiceException.prototype.isPrototypeOf(candidate) || Boolean(candidate.$fault) && Boolean(candidate.$metadata) && (candidate.$fault === "client" || candidate.$fault === "server");
+  }
+  static [Symbol.hasInstance](instance) {
+    if (!instance)
+      return false;
+    const candidate = instance;
+    if (this === _ServiceException) {
+      return _ServiceException.isInstance(instance);
+    }
+    if (_ServiceException.isInstance(instance)) {
+      if (candidate.name && this.name) {
+        return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
+      }
+      return this.prototype.isPrototypeOf(instance);
+    }
+    return false;
+  }
+};
+var decorateServiceException = (exception, additions = {}) => {
+  Object.entries(additions).filter(([, v]) => v !== void 0).forEach(([k, v]) => {
+    if (exception[k] == void 0 || exception[k] === "") {
+      exception[k] = v;
+    }
+  });
+  const message = exception.message || exception.Message || "UnknownError";
+  exception.message = message;
+  delete exception.Message;
+  return exception;
+};
+
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/cache/EndpointCache.js
 var EndpointCache = class {
+  capacity;
+  data = /* @__PURE__ */ new Map();
+  parameters = [];
   constructor({ size, params }) {
-    this.data = /* @__PURE__ */ new Map();
-    this.parameters = [];
     this.capacity = size ?? 50;
     if (params) {
       this.parameters = params;
@@ -549,11 +2028,11 @@ var EndpointCache = class {
   }
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/isIpAddress.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/isIpAddress.js
 var IP_V4_REGEX = new RegExp(`^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$`);
 var isIpAddress = (value) => IP_V4_REGEX.test(value) || value.startsWith("[") && value.endsWith("]");
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/isValidHostLabel.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/isValidHostLabel.js
 var VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
 var isValidHostLabel = (value, allowSubDomains = false) => {
   if (!allowSubDomains) {
@@ -568,13 +2047,13 @@ var isValidHostLabel = (value, allowSubDomains = false) => {
   return true;
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/customEndpointFunctions.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/customEndpointFunctions.js
 var customEndpointFunctions = {};
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/debug/debugId.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/debug/debugId.js
 var debugId = "endpoints";
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/debug/toDebugString.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/debug/toDebugString.js
 function toDebugString(input) {
   if (typeof input !== "object" || input == null) {
     return input;
@@ -588,7 +2067,7 @@ function toDebugString(input) {
   return JSON.stringify(input, null, 2);
 }
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/types/EndpointError.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/types/EndpointError.js
 var EndpointError = class extends Error {
   constructor(message) {
     super(message);
@@ -596,10 +2075,10 @@ var EndpointError = class extends Error {
   }
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/booleanEquals.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/booleanEquals.js
 var booleanEquals = (value1, value2) => value1 === value2;
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/getAttrPathList.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/getAttrPathList.js
 var getAttrPathList = (path) => {
   const parts = path.split(".");
   const pathList = [];
@@ -624,7 +2103,7 @@ var getAttrPathList = (path) => {
   return pathList;
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/getAttr.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/getAttr.js
 var getAttr = (value, path) => getAttrPathList(path).reduce((acc, index) => {
   if (typeof acc !== "object") {
     throw new EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`);
@@ -634,13 +2113,13 @@ var getAttr = (value, path) => getAttrPathList(path).reduce((acc, index) => {
   return acc[index];
 }, value);
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/isSet.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/isSet.js
 var isSet = (value) => value != null;
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/not.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/not.js
 var not = (value) => !value;
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/parseURL.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/parseURL.js
 var DEFAULT_PORTS = {
   [EndpointURLScheme.HTTP]: 80,
   [EndpointURLScheme.HTTPS]: 443
@@ -687,10 +2166,10 @@ var parseURL = (value) => {
   };
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/stringEquals.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/stringEquals.js
 var stringEquals = (value1, value2) => value1 === value2;
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/substring.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/substring.js
 var substring = (input, start, stop, reverse) => {
   if (start >= stop || input.length < stop) {
     return null;
@@ -701,10 +2180,10 @@ var substring = (input, start, stop, reverse) => {
   return input.substring(input.length - stop, input.length - start);
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/lib/uriEncode.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/lib/uriEncode.js
 var uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/endpointFunctions.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/endpointFunctions.js
 var endpointFunctions = {
   booleanEquals,
   getAttr,
@@ -717,7 +2196,7 @@ var endpointFunctions = {
   uriEncode
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTemplate.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTemplate.js
 var evaluateTemplate = (template, options) => {
   const evaluatedTemplateArr = [];
   const templateContext = {
@@ -753,7 +2232,7 @@ var evaluateTemplate = (template, options) => {
   return evaluatedTemplateArr.join("");
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/getReferenceValue.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/getReferenceValue.js
 var getReferenceValue = ({ ref }, options) => {
   const referenceRecord = {
     ...options.endpointParams,
@@ -762,29 +2241,31 @@ var getReferenceValue = ({ ref }, options) => {
   return referenceRecord[ref];
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateExpression.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateExpression.js
 var evaluateExpression = (obj, keyName, options) => {
   if (typeof obj === "string") {
     return evaluateTemplate(obj, options);
   } else if (obj["fn"]) {
-    return callFunction(obj, options);
+    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.`);
 };
-
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/callFunction.js
 var callFunction = ({ fn, argv }, options) => {
-  const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : evaluateExpression(arg, "arg", options));
+  const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : group.evaluateExpression(arg, "arg", options));
   const fnSegments = fn.split(".");
   if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {
     return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);
   }
   return endpointFunctions[fn](...evaluatedArgs);
 };
+var group = {
+  evaluateExpression,
+  callFunction
+};
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateCondition.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateCondition.js
 var evaluateCondition = ({ assign, ...fnArgs }, options) => {
   if (assign && assign in options.referenceRecord) {
     throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
@@ -797,7 +2278,7 @@ var evaluateCondition = ({ assign, ...fnArgs }, options) => {
   };
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateConditions.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateConditions.js
 var evaluateConditions = (conditions = [], options) => {
   const conditionsReferenceRecord = {};
   for (const condition of conditions) {
@@ -819,7 +2300,7 @@ var evaluateConditions = (conditions = [], options) => {
   return { result: true, referenceRecord: conditionsReferenceRecord };
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointHeaders.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointHeaders.js
 var getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((acc, [headerKey, headerVal]) => ({
   ...acc,
   [headerKey]: headerVal.map((headerValEntry) => {
@@ -831,7 +2312,11 @@ var getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((a
   })
 }), {});
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperty.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js
+var getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
+  ...acc,
+  [propertyKey]: group2.getEndpointProperty(propertyVal, options)
+}), {});
 var getEndpointProperty = (property, options) => {
   if (Array.isArray(property)) {
     return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
@@ -843,21 +2328,19 @@ var getEndpointProperty = (property, options) => {
       if (property === null) {
         throw new EndpointError(`Unexpected endpoint property: ${property}`);
       }
-      return getEndpointProperties(property, options);
+      return group2.getEndpointProperties(property, options);
     case "boolean":
       return property;
     default:
       throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
   }
 };
+var group2 = {
+  getEndpointProperty,
+  getEndpointProperties
+};
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js
-var getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
-  ...acc,
-  [propertyKey]: getEndpointProperty(propertyVal, options)
-}), {});
-
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointUrl.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointUrl.js
 var getEndpointUrl = (endpointUrl, options) => {
   const expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
   if (typeof expression === "string") {
@@ -871,7 +2354,7 @@ var getEndpointUrl = (endpointUrl, options) => {
   throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateEndpointRule.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateEndpointRule.js
 var evaluateEndpointRule = (endpointRule, options) => {
   const { conditions, endpoint } = endpointRule;
   const { result, referenceRecord } = evaluateConditions(conditions, options);
@@ -895,7 +2378,7 @@ var evaluateEndpointRule = (endpointRule, options) => {
   };
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateErrorRule.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateErrorRule.js
 var evaluateErrorRule = (errorRule, options) => {
   const { conditions, error } = errorRule;
   const { result, referenceRecord } = evaluateConditions(conditions, options);
@@ -908,20 +2391,7 @@ var evaluateErrorRule = (errorRule, options) => {
   }));
 };
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTreeRule.js
-var evaluateTreeRule = (treeRule, options) => {
-  const { conditions, rules } = treeRule;
-  const { result, referenceRecord } = evaluateConditions(conditions, options);
-  if (!result) {
-    return;
-  }
-  return evaluateRules(rules, {
-    ...options,
-    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
-  });
-};
-
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js
 var evaluateRules = (rules, options) => {
   for (const rule of rules) {
     if (rule.type === "endpoint") {
@@ -932,7 +2402,7 @@ var evaluateRules = (rules, options) => {
     } else if (rule.type === "error") {
       evaluateErrorRule(rule, options);
     } else if (rule.type === "tree") {
-      const endpointOrUndefined = evaluateTreeRule(rule, options);
+      const endpointOrUndefined = group3.evaluateTreeRule(rule, options);
       if (endpointOrUndefined) {
         return endpointOrUndefined;
       }
@@ -942,8 +2412,23 @@ var evaluateRules = (rules, options) => {
   }
   throw new EndpointError(`Rules evaluation failed`);
 };
+var evaluateTreeRule = (treeRule, options) => {
+  const { conditions, rules } = treeRule;
+  const { result, referenceRecord } = evaluateConditions(conditions, options);
+  if (!result) {
+    return;
+  }
+  return group3.evaluateRules(rules, {
+    ...options,
+    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
+  });
+};
+var group3 = {
+  evaluateRules,
+  evaluateTreeRule
+};
 
-// ../../.yarn/cache/@smithy-util-endpoints-npm-3.0.5-7de1befdda-95d00d9a0e.zip/node_modules/@smithy/util-endpoints/dist-es/resolveEndpoint.js
+// ../../.yarn/cache/@smithy-util-endpoints-npm-3.2.5-99c061e0fe-919767b499.zip/node_modules/@smithy/util-endpoints/dist-es/resolveEndpoint.js
 var resolveEndpoint = (ruleSetObject, options) => {
   const { endpointParams, logger } = options;
   const { parameters, rules } = ruleSetObject;
@@ -965,7 +2450,7 @@ var resolveEndpoint = (ruleSetObject, options) => {
   return endpoint;
 };
 
-// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.808.0-43cec0322b-197e07aa97.zip/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/isVirtualHostableS3Bucket.js
+// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.936.0-bf91c0e536-13b1ae923e.zip/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/isVirtualHostableS3Bucket.js
 var isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
   if (allowSubDomains) {
     for (const label of value.split(".")) {
@@ -990,7 +2475,7 @@ var isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
   return true;
 };
 
-// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.808.0-43cec0322b-197e07aa97.zip/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/parseArn.js
+// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.936.0-bf91c0e536-13b1ae923e.zip/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/parseArn.js
 var ARN_DELIMITER = ":";
 var RESOURCE_DELIMITER = "/";
 var parseArn = (value) => {
@@ -1010,7 +2495,7 @@ var parseArn = (value) => {
   };
 };
 
-// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.808.0-43cec0322b-197e07aa97.zip/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partitions.json
+// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.936.0-bf91c0e536-13b1ae923e.zip/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partitions.json
 var partitions_default = {
   partitions: [{
     id: "aws",
@@ -1030,6 +2515,9 @@ var partitions_default = {
       "ap-east-1": {
         description: "Asia Pacific (Hong Kong)"
       },
+      "ap-east-2": {
+        description: "Asia Pacific (Taipei)"
+      },
       "ap-northeast-1": {
         description: "Asia Pacific (Tokyo)"
       },
@@ -1060,11 +2548,14 @@ var partitions_default = {
       "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 Standard global region"
+        description: "aws global region"
       },
       "ca-central-1": {
         description: "Canada (Central)"
@@ -1137,7 +2628,7 @@ var partitions_default = {
     regionRegex: "^cn\\-\\w+\\-\\d+$",
     regions: {
       "aws-cn-global": {
-        description: "AWS China global region"
+        description: "aws-cn global region"
       },
       "cn-north-1": {
         description: "China (Beijing)"
@@ -1147,41 +2638,35 @@ var partitions_default = {
       }
     }
   }, {
-    id: "aws-us-gov",
+    id: "aws-eusc",
     outputs: {
-      dnsSuffix: "amazonaws.com",
-      dualStackDnsSuffix: "api.aws",
-      implicitGlobalRegion: "us-gov-west-1",
-      name: "aws-us-gov",
+      dnsSuffix: "amazonaws.eu",
+      dualStackDnsSuffix: "api.amazonwebservices.eu",
+      implicitGlobalRegion: "eusc-de-east-1",
+      name: "aws-eusc",
       supportsDualStack: true,
       supportsFIPS: true
     },
-    regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
+    regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$",
     regions: {
-      "aws-us-gov-global": {
-        description: "AWS GovCloud (US) global region"
-      },
-      "us-gov-east-1": {
-        description: "AWS GovCloud (US-East)"
-      },
-      "us-gov-west-1": {
-        description: "AWS GovCloud (US-West)"
+      "eusc-de-east-1": {
+        description: "EU (Germany)"
       }
     }
   }, {
     id: "aws-iso",
     outputs: {
       dnsSuffix: "c2s.ic.gov",
-      dualStackDnsSuffix: "c2s.ic.gov",
+      dualStackDnsSuffix: "api.aws.ic.gov",
       implicitGlobalRegion: "us-iso-east-1",
       name: "aws-iso",
-      supportsDualStack: false,
+      supportsDualStack: true,
       supportsFIPS: true
     },
     regionRegex: "^us\\-iso\\-\\w+\\-\\d+$",
     regions: {
       "aws-iso-global": {
-        description: "AWS ISO (US) global region"
+        description: "aws-iso global region"
       },
       "us-iso-east-1": {
         description: "US ISO East"
@@ -1194,35 +2679,38 @@ var partitions_default = {
     id: "aws-iso-b",
     outputs: {
       dnsSuffix: "sc2s.sgov.gov",
-      dualStackDnsSuffix: "sc2s.sgov.gov",
+      dualStackDnsSuffix: "api.aws.scloud",
       implicitGlobalRegion: "us-isob-east-1",
       name: "aws-iso-b",
-      supportsDualStack: false,
+      supportsDualStack: true,
       supportsFIPS: true
     },
     regionRegex: "^us\\-isob\\-\\w+\\-\\d+$",
     regions: {
       "aws-iso-b-global": {
-        description: "AWS ISOB (US) global region"
+        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: "cloud.adc-e.uk",
+      dualStackDnsSuffix: "api.cloud-aws.adc-e.uk",
       implicitGlobalRegion: "eu-isoe-west-1",
       name: "aws-iso-e",
-      supportsDualStack: false,
+      supportsDualStack: true,
       supportsFIPS: true
     },
     regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$",
     regions: {
       "aws-iso-e-global": {
-        description: "AWS ISOE (Europe) global region"
+        description: "aws-iso-e global region"
       },
       "eu-isoe-west-1": {
         description: "EU ISOE West"
@@ -1232,16 +2720,16 @@ var partitions_default = {
     id: "aws-iso-f",
     outputs: {
       dnsSuffix: "csp.hci.ic.gov",
-      dualStackDnsSuffix: "csp.hci.ic.gov",
+      dualStackDnsSuffix: "api.aws.hci.ic.gov",
       implicitGlobalRegion: "us-isof-south-1",
       name: "aws-iso-f",
-      supportsDualStack: false,
+      supportsDualStack: true,
       supportsFIPS: true
     },
     regionRegex: "^us\\-isof\\-\\w+\\-\\d+$",
     regions: {
       "aws-iso-f-global": {
-        description: "AWS ISOF global region"
+        description: "aws-iso-f global region"
       },
       "us-isof-east-1": {
         description: "US ISOF EAST"
@@ -1251,26 +2739,32 @@ var partitions_default = {
       }
     }
   }, {
-    id: "aws-eusc",
+    id: "aws-us-gov",
     outputs: {
-      dnsSuffix: "amazonaws.eu",
-      dualStackDnsSuffix: "amazonaws.eu",
-      implicitGlobalRegion: "eusc-de-east-1",
-      name: "aws-eusc",
-      supportsDualStack: false,
+      dnsSuffix: "amazonaws.com",
+      dualStackDnsSuffix: "api.aws",
+      implicitGlobalRegion: "us-gov-west-1",
+      name: "aws-us-gov",
+      supportsDualStack: true,
       supportsFIPS: true
     },
-    regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$",
+    regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
     regions: {
-      "eusc-de-east-1": {
-        description: "EU (Germany)"
+      "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"
 };
 
-// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.808.0-43cec0322b-197e07aa97.zip/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partition.js
+// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.936.0-bf91c0e536-13b1ae923e.zip/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partition.js
 var selectedPartitionsInfo = partitions_default;
 var selectedUserAgentPrefix = "";
 var partition = (value) => {
@@ -1304,7 +2798,7 @@ var partition = (value) => {
 };
 var getUserAgentPrefix = () => selectedUserAgentPrefix;
 
-// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.808.0-43cec0322b-197e07aa97.zip/node_modules/@aws-sdk/util-endpoints/dist-es/aws.js
+// ../../.yarn/cache/@aws-sdk-util-endpoints-npm-3.936.0-bf91c0e536-13b1ae923e.zip/node_modules/@aws-sdk/util-endpoints/dist-es/aws.js
 var awsEndpointFunctions = {
   isVirtualHostableS3Bucket,
   parseArn,
@@ -1312,7 +2806,7 @@ var awsEndpointFunctions = {
 };
 customEndpointFunctions.aws = awsEndpointFunctions;
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/client/emitWarningIfUnsupportedVersion.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/client/emitWarningIfUnsupportedVersion.js
 var state = {
   warningEmitted: false
 };
@@ -1329,7 +2823,7 @@ More information can be found at: https://a.co/74kJMmI`);
   }
 };
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/client/setFeature.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/client/setFeature.js
 function setFeature2(context, feature, value) {
   if (!context.__aws_sdk_context) {
     context.__aws_sdk_context = {
@@ -1341,16 +2835,16 @@ function setFeature2(context, feature, value) {
   context.__aws_sdk_context.features[feature] = value;
 }
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getDateHeader.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getDateHeader.js
 var getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : void 0;
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getSkewCorrectedDate.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getSkewCorrectedDate.js
 var getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/isClockSkewed.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/isClockSkewed.js
 var isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 3e5;
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getUpdatedSystemClockOffset.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getUpdatedSystemClockOffset.js
 var getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
   const clockTimeInMs = Date.parse(clockTime);
   if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
@@ -1359,7 +2853,7 @@ var getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
   return currentSystemClockOffset;
 };
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.js
 var throwSigningPropertyError = (name, property) => {
   if (!property) {
     throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`);
@@ -1430,13 +2924,13 @@ var AwsSdkSigV4Signer = class {
   }
 };
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getArrayForCommaSeparatedString.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getArrayForCommaSeparatedString.js
 var getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : [];
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getBearerTokenEnvKey.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getBearerTokenEnvKey.js
 var getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`;
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/NODE_AUTH_SCHEME_PREFERENCE_OPTIONS.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/NODE_AUTH_SCHEME_PREFERENCE_OPTIONS.js
 var NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE";
 var NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference";
 var NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = {
@@ -1458,7 +2952,7 @@ var NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = {
   default: []
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/constants.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/constants.js
 var ALGORITHM_QUERY_PARAM = "X-Amz-Algorithm";
 var CREDENTIAL_QUERY_PARAM = "X-Amz-Credential";
 var AMZ_DATE_QUERY_PARAM = "X-Amz-Date";
@@ -1499,7 +2993,7 @@ var MAX_CACHE_SIZE = 50;
 var KEY_TYPE_IDENTIFIER = "aws4_request";
 var MAX_PRESIGNED_TTL = 60 * 60 * 24 * 7;
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/credentialDerivation.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/credentialDerivation.js
 var signingKeyCache = {};
 var cacheQueue = [];
 var createScope = (shortDate, region, service) => `${shortDate}/${region}/${service}/${KEY_TYPE_IDENTIFIER}`;
@@ -1525,7 +3019,7 @@ var hmac = (ctor, secret, data) => {
   return hash.digest();
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/getCanonicalHeaders.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/getCanonicalHeaders.js
 var getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
   const canonical = {};
   for (const headerName of Object.keys(headers).sort()) {
@@ -1543,7 +3037,7 @@ var getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
   return canonical;
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/getPayloadHash.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/getPayloadHash.js
 var getPayloadHash = async ({ headers, body }, hashConstructor) => {
   for (const headerName of Object.keys(headers)) {
     if (headerName.toLowerCase() === SHA256_HEADER) {
@@ -1560,7 +3054,7 @@ var getPayloadHash = async ({ headers, body }, hashConstructor) => {
   return UNSIGNED_PAYLOAD;
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/HeaderFormatter.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/HeaderFormatter.js
 var HeaderFormatter = class {
   format(headers) {
     const chunks = [];
@@ -1643,6 +3137,7 @@ var HEADER_VALUE_TYPE;
 })(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
 var UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
 var Int64 = class _Int64 {
+  bytes;
   constructor(bytes) {
     this.bytes = bytes;
     if (bytes.byteLength !== 8) {
@@ -1685,7 +3180,7 @@ function negate(bytes) {
   }
 }
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/headerUtil.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/headerUtil.js
 var hasHeader = (soughtHeader, headers) => {
   soughtHeader = soughtHeader.toLowerCase();
   for (const headerName of Object.keys(headers)) {
@@ -1696,7 +3191,7 @@ var hasHeader = (soughtHeader, headers) => {
   return false;
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/moveHeadersToQuery.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/moveHeadersToQuery.js
 var moveHeadersToQuery = (request, options = {}) => {
   const { headers, query = {} } = HttpRequest.clone(request);
   for (const name of Object.keys(headers)) {
@@ -1713,7 +3208,7 @@ var moveHeadersToQuery = (request, options = {}) => {
   };
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/prepareRequest.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/prepareRequest.js
 var prepareRequest = (request) => {
   request = HttpRequest.clone(request);
   for (const headerName of Object.keys(request.headers)) {
@@ -1724,7 +3219,7 @@ var prepareRequest = (request) => {
   return request;
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/getCanonicalQuery.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/getCanonicalQuery.js
 var getCanonicalQuery = ({ query = {} }) => {
   const keys = [];
   const serialized = {};
@@ -1744,23 +3239,29 @@ var getCanonicalQuery = ({ query = {} }) => {
   return keys.sort().map((key) => serialized[key]).filter((serialized2) => serialized2).join("&");
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/utilDate.js
-var iso8601 = (time) => toDate(time).toISOString().replace(/\.\d{3}Z$/, "Z");
-var toDate = (time) => {
-  if (typeof time === "number") {
-    return new Date(time * 1e3);
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/utilDate.js
+var iso8601 = (time2) => toDate(time2).toISOString().replace(/\.\d{3}Z$/, "Z");
+var toDate = (time2) => {
+  if (typeof time2 === "number") {
+    return new Date(time2 * 1e3);
   }
-  if (typeof time === "string") {
-    if (Number(time)) {
-      return new Date(Number(time) * 1e3);
+  if (typeof time2 === "string") {
+    if (Number(time2)) {
+      return new Date(Number(time2) * 1e3);
     }
-    return new Date(time);
+    return new Date(time2);
   }
-  return time;
+  return time2;
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/SignatureV4Base.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/SignatureV4Base.js
 var SignatureV4Base = class {
+  service;
+  regionProvider;
+  credentialProvider;
+  sha256;
+  uriEscapePath;
+  applyChecksum;
   constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
     this.service = service;
     this.sha256 = sha256;
@@ -1825,8 +3326,9 @@ ${toHex(hashedRequest)}`;
   }
 };
 
-// ../../.yarn/cache/@smithy-signature-v4-npm-5.1.1-1b3dab9983-e0e4d414c7.zip/node_modules/@smithy/signature-v4/dist-es/SignatureV4.js
+// ../../.yarn/cache/@smithy-signature-v4-npm-5.3.5-e0b4efa55d-e4e8f28fc5.zip/node_modules/@smithy/signature-v4/dist-es/SignatureV4.js
 var SignatureV4 = class extends SignatureV4Base {
+  headerFormatter = new HeaderFormatter();
   constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
     super({
       applyChecksum,
@@ -1836,7 +3338,6 @@ var SignatureV4 = class extends SignatureV4Base {
       sha256,
       uriEscapePath
     });
-    this.headerFormatter = new HeaderFormatter();
   }
   async presign(originalRequest, options = {}) {
     const { signingDate = /* @__PURE__ */ new Date(), expiresIn = 3600, unsignableHeaders, unhoistableHeaders, signableHeaders, hoistableHeaders, signingRegion, signingService } = options;
@@ -1944,7 +3445,7 @@ var SignatureV4 = class extends SignatureV4Base {
   }
 };
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.js
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.js
 var resolveAwsSdkSigV4Config = (config) => {
   let inputCredentials = config.credentials;
   let isUserSupplied = !!config.credentials;
@@ -2065,10 +3566,259 @@ function bindCallerConfig(config, credentialsProvider) {
   return fn;
 }
 
-// ../../.yarn/cache/@aws-sdk-core-npm-3.816.0-71722eb284-f11ab1da51.zip/node_modules/@aws-sdk/core/dist-es/submodules/protocols/common.js
-var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/defaults-mode.js
+var loadConfigsForDefaultMode = (mode) => {
+  switch (mode) {
+    case "standard":
+      return {
+        retryMode: "standard",
+        connectionTimeout: 3100
+      };
+    case "in-region":
+      return {
+        retryMode: "standard",
+        connectionTimeout: 1100
+      };
+    case "cross-region":
+      return {
+        retryMode: "standard",
+        connectionTimeout: 3100
+      };
+    case "mobile":
+      return {
+        retryMode: "standard",
+        connectionTimeout: 3e4
+      };
+    default:
+      return {};
+  }
+};
+
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/emitWarningIfUnsupportedVersion.js
+var warningEmitted = false;
+var emitWarningIfUnsupportedVersion2 = (version) => {
+  if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
+    warningEmitted = true;
+  }
+};
+
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/extensions/checksum.js
+var getChecksumConfiguration = (runtimeConfig) => {
+  const checksumAlgorithms = [];
+  for (const id in AlgorithmId) {
+    const algorithmId = AlgorithmId[id];
+    if (runtimeConfig[algorithmId] === void 0) {
+      continue;
+    }
+    checksumAlgorithms.push({
+      algorithmId: () => algorithmId,
+      checksumConstructor: () => runtimeConfig[algorithmId]
+    });
+  }
+  return {
+    addChecksumAlgorithm(algo) {
+      checksumAlgorithms.push(algo);
+    },
+    checksumAlgorithms() {
+      return checksumAlgorithms;
+    }
+  };
+};
+var resolveChecksumRuntimeConfig = (clientConfig) => {
+  const runtimeConfig = {};
+  clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
+    runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
+  });
+  return runtimeConfig;
+};
+
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/extensions/retry.js
+var getRetryConfiguration = (runtimeConfig) => {
+  return {
+    setRetryStrategy(retryStrategy) {
+      runtimeConfig.retryStrategy = retryStrategy;
+    },
+    retryStrategy() {
+      return runtimeConfig.retryStrategy;
+    }
+  };
+};
+var resolveRetryRuntimeConfig = (retryStrategyConfiguration) => {
+  const runtimeConfig = {};
+  runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy();
+  return runtimeConfig;
+};
+
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/extensions/defaultExtensionConfiguration.js
+var getDefaultExtensionConfiguration = (runtimeConfig) => {
+  return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));
+};
+var resolveDefaultRuntimeConfig = (config) => {
+  return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config));
+};
+
+// ../../.yarn/cache/@smithy-smithy-client-npm-4.9.8-803f5201c0-42752686da.zip/node_modules/@smithy/smithy-client/dist-es/NoOpLogger.js
+var NoOpLogger = class {
+  trace() {
+  }
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+};
+
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/protocols/ProtocolLib.js
+var ProtocolLib = class {
+  queryCompat;
+  constructor(queryCompat = false) {
+    this.queryCompat = queryCompat;
+  }
+  resolveRestContentType(defaultContentType, inputSchema) {
+    const members = inputSchema.getMemberSchemas();
+    const httpPayloadMember = Object.values(members).find((m) => {
+      return !!m.getMergedTraits().httpPayload;
+    });
+    if (httpPayloadMember) {
+      const mediaType = httpPayloadMember.getMergedTraits().mediaType;
+      if (mediaType) {
+        return mediaType;
+      } else if (httpPayloadMember.isStringSchema()) {
+        return "text/plain";
+      } else if (httpPayloadMember.isBlobSchema()) {
+        return "application/octet-stream";
+      } else {
+        return defaultContentType;
+      }
+    } else if (!inputSchema.isUnitSchema()) {
+      const hasBody = Object.values(members).find((m) => {
+        const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
+        const noPrefixHeaders = httpPrefixHeaders === void 0;
+        return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && noPrefixHeaders;
+      });
+      if (hasBody) {
+        return defaultContentType;
+      }
+    }
+  }
+  async getErrorSchemaOrThrowBaseException(errorIdentifier, defaultNamespace, response, dataObject, metadata, getErrorSchema) {
+    let namespace = defaultNamespace;
+    let errorName = errorIdentifier;
+    if (errorIdentifier.includes("#")) {
+      [namespace, errorName] = errorIdentifier.split("#");
+    }
+    const errorMetadata = {
+      $metadata: metadata,
+      $fault: response.statusCode < 500 ? "client" : "server"
+    };
+    const registry = TypeRegistry.for(namespace);
+    try {
+      const errorSchema = getErrorSchema?.(registry, errorName) ?? registry.getSchema(errorIdentifier);
+      return { errorSchema, errorMetadata };
+    } catch (e) {
+      dataObject.message = dataObject.message ?? dataObject.Message ?? "UnknownError";
+      const synthetic = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+      const baseExceptionSchema = synthetic.getBaseException();
+      if (baseExceptionSchema) {
+        const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema) ?? Error;
+        throw this.decorateServiceException(Object.assign(new ErrorCtor({ name: errorName }), errorMetadata), dataObject);
+      }
+      throw this.decorateServiceException(Object.assign(new Error(errorName), errorMetadata), dataObject);
+    }
+  }
+  decorateServiceException(exception, additions = {}) {
+    if (this.queryCompat) {
+      const msg = exception.Message ?? additions.Message;
+      const error = decorateServiceException(exception, additions);
+      if (msg) {
+        error.Message = msg;
+        error.message = msg;
+      }
+      return error;
+    }
+    return decorateServiceException(exception, additions);
+  }
+  setQueryCompatError(output, response) {
+    const queryErrorHeader = response.headers?.["x-amzn-query-error"];
+    if (output !== void 0 && queryErrorHeader != null) {
+      const [Code, Type] = queryErrorHeader.split(";");
+      const entries = Object.entries(output);
+      const Error2 = {
+        Code,
+        Type
+      };
+      Object.assign(output, Error2);
+      for (const [k, v] of entries) {
+        Error2[k] = v;
+      }
+      delete Error2.__type;
+      output.Error = Error2;
+    }
+  }
+  queryCompatOutput(queryCompatErrorData, errorData) {
+    if (queryCompatErrorData.Error) {
+      errorData.Error = queryCompatErrorData.Error;
+    }
+    if (queryCompatErrorData.Type) {
+      errorData.Type = queryCompatErrorData.Type;
+    }
+    if (queryCompatErrorData.Code) {
+      errorData.Code = queryCompatErrorData.Code;
+    }
+  }
+};
+
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/protocols/ConfigurableSerdeContext.js
+var SerdeContextConfig = class {
+  serdeContext;
+  setSerdeContext(serdeContext) {
+    this.serdeContext = serdeContext;
+  }
+};
+
+// ../../.yarn/cache/@aws-sdk-core-npm-3.940.0-0d32a8e8d2-090b960007.zip/node_modules/@aws-sdk/core/dist-es/submodules/protocols/structIterator.js
+function* serializingStructIterator(ns, sourceObject) {
+  if (ns.isUnitSchema()) {
+    return;
+  }
+  const struct = ns.getSchema();
+  for (let i = 0; i < struct[4].length; ++i) {
+    const key = struct[4][i];
+    const memberNs = new NormalizedSchema([struct[5][i], 0], key);
+    if (!(key in sourceObject) && !memberNs.isIdempotencyToken()) {
+      continue;
+    }
+    yield [key, memberNs];
+  }
+}
+function* deserializingStructIterator(ns, sourceObject, nameTrait) {
+  if (ns.isUnitSchema()) {
+    return;
+  }
+  const struct = ns.getSchema();
+  let keysRemaining = Object.keys(sourceObject).length;
+  for (let i = 0; i < struct[4].length; ++i) {
+    if (keysRemaining === 0) {
+      break;
+    }
+    const key = struct[4][i];
+    const memberNs = new NormalizedSchema([struct[5][i], 0], key);
+    let serializationKey = key;
+    if (nameTrait) {
+      serializationKey = memberNs.getMergedTraits()[nameTrait] ?? key;
+    }
+    if (!(serializationKey in sourceObject)) {
+      continue;
+    }
+    yield [key, memberNs];
+    keysRemaining -= 1;
+  }
+}
 
-// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.816.0-e8bdacf6e2-af3caa6df1.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/check-features.js
+// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.940.0-3e822100ad-1756e35c96.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/check-features.js
 var ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
 async function checkFeatures(context, config, args) {
   const request = args.request;
@@ -2116,16 +3866,16 @@ async function checkFeatures(context, config, args) {
   }
 }
 
-// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.816.0-e8bdacf6e2-af3caa6df1.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/constants.js
+// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.940.0-3e822100ad-1756e35c96.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/constants.js
 var USER_AGENT = "user-agent";
 var X_AMZ_USER_AGENT = "x-amz-user-agent";
 var SPACE = " ";
 var UA_NAME_SEPARATOR = "/";
-var UA_NAME_ESCAPE_REGEX = /[^\!\$\%\&\'\*\+\-\.\^\_\`\|\~\d\w]/g;
-var UA_VALUE_ESCAPE_REGEX = /[^\!\$\%\&\'\*\+\-\.\^\_\`\|\~\d\w\#]/g;
+var UA_NAME_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w]/g;
+var UA_VALUE_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w#]/g;
 var UA_ESCAPE_CHAR = "-";
 
-// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.816.0-e8bdacf6e2-af3caa6df1.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/encode-features.js
+// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.940.0-3e822100ad-1756e35c96.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/encode-features.js
 var BYTE_LIMIT = 1024;
 function encodeFeatures(features) {
   let buffer = "";
@@ -2144,7 +3894,7 @@ function encodeFeatures(features) {
   return buffer;
 }
 
-// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.816.0-e8bdacf6e2-af3caa6df1.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/user-agent-middleware.js
+// ../../.yarn/cache/@aws-sdk-middleware-user-agent-npm-3.940.0-3e822100ad-1756e35c96.zip/node_modules/@aws-sdk/middleware-user-agent/dist-es/user-agent-middleware.js
 var userAgentMiddleware = (options) => (next, context) => async (args) => {
   const { request } = args;
   if (!HttpRequest.isInstance(request)) {
@@ -2159,7 +3909,7 @@ var userAgentMiddleware = (options) => (next, context) => async (args) => {
   const customUserAgent = options?.customUserAgent?.map(escapeUserAgent) || [];
   const appId = await options.userAgentAppId();
   if (appId) {
-    defaultUserAgent.push(escapeUserAgent([`app/${appId}`]));
+    defaultUserAgent.push(escapeUserAgent([`app`, `${appId}`]));
   }
   const prefix = getUserAgentPrefix();
   const sdkUserAgentValue = (prefix ? [prefix] : []).concat([...defaultUserAgent, ...userAgent, ...customUserAgent]).join(SPACE);
@@ -2213,13 +3963,27 @@ var getUserAgentPlugin = (config) => ({
   }
 });
 
-// ../../.yarn/cache/@smithy-config-resolver-npm-4.1.3-08af992379-6ec52e1609.zip/node_modules/@smithy/config-resolver/dist-es/regionConfig/isFipsRegion.js
+// ../../.yarn/cache/@smithy-config-resolver-npm-4.4.3-995b58e856-e28844ea32.zip/node_modules/@smithy/config-resolver/dist-es/regionConfig/checkRegion.js
+var validRegions = /* @__PURE__ */ new Set();
+var checkRegion = (region, check = isValidHostLabel) => {
+  if (!validRegions.has(region) && !check(region)) {
+    if (region === "*") {
+      console.warn(`@smithy/config-resolver WARN - Please use the caller region instead of "*". See "sigv4a" in https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md.`);
+    } else {
+      throw new Error(`Region not accepted: region="${region}" is not a valid hostname component.`);
+    }
+  } else {
+    validRegions.add(region);
+  }
+};
+
+// ../../.yarn/cache/@smithy-config-resolver-npm-4.4.3-995b58e856-e28844ea32.zip/node_modules/@smithy/config-resolver/dist-es/regionConfig/isFipsRegion.js
 var isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));
 
-// ../../.yarn/cache/@smithy-config-resolver-npm-4.1.3-08af992379-6ec52e1609.zip/node_modules/@smithy/config-resolver/dist-es/regionConfig/getRealRegion.js
+// ../../.yarn/cache/@smithy-config-resolver-npm-4.4.3-995b58e856-e28844ea32.zip/node_modules/@smithy/config-resolver/dist-es/regionConfig/getRealRegion.js
 var getRealRegion = (region) => isFipsRegion(region) ? ["fips-aws-global", "aws-fips"].includes(region) ? "us-east-1" : region.replace(/fips-(dkr-|prod-)?|-fips/, "") : region;
 
-// ../../.yarn/cache/@smithy-config-resolver-npm-4.1.3-08af992379-6ec52e1609.zip/node_modules/@smithy/config-resolver/dist-es/regionConfig/resolveRegionConfig.js
+// ../../.yarn/cache/@smithy-config-resolver-npm-4.4.3-995b58e856-e28844ea32.zip/node_modules/@smithy/config-resolver/dist-es/regionConfig/resolveRegionConfig.js
 var resolveRegionConfig = (input) => {
   const { region, useFipsEndpoint } = input;
   if (!region) {
@@ -2227,11 +3991,10 @@ var resolveRegionConfig = (input) => {
   }
   return Object.assign(input, {
     region: async () => {
-      if (typeof region === "string") {
-        return getRealRegion(region);
-      }
-      const providedRegion = await region();
-      return getRealRegion(providedRegion);
+      const providedRegion = typeof region === "function" ? await region() : region;
+      const realRegion = getRealRegion(providedRegion);
+      checkRegion(realRegion);
+      return realRegion;
     },
     useFipsEndpoint: async () => {
       const providedRegion = typeof region === "string" ? region : await region();
@@ -2243,57 +4006,7 @@ var resolveRegionConfig = (input) => {
   });
 };
 
-// ../../.yarn/cache/@smithy-util-config-provider-npm-4.0.0-f9e394b66a-cd9498d5f7.zip/node_modules/@smithy/util-config-provider/dist-es/booleanSelector.js
-var booleanSelector = (obj, key, type) => {
-  if (!(key in obj))
-    return void 0;
-  if (obj[key] === "true")
-    return true;
-  if (obj[key] === "false")
-    return false;
-  throw new Error(`Cannot load ${type} "${key}". Expected "true" or "false", got ${obj[key]}.`);
-};
-
-// ../../.yarn/cache/@smithy-util-config-provider-npm-4.0.0-f9e394b66a-cd9498d5f7.zip/node_modules/@smithy/util-config-provider/dist-es/types.js
-var SelectorType;
-(function(SelectorType2) {
-  SelectorType2["ENV"] = "env";
-  SelectorType2["CONFIG"] = "shared config entry";
-})(SelectorType || (SelectorType = {}));
-
-// ../../.yarn/cache/@smithy-config-resolver-npm-4.1.3-08af992379-6ec52e1609.zip/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseDualstackEndpointConfigOptions.js
-var ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
-var CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
-var NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => booleanSelector(env2, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
-  configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
-  default: false
-};
-
-// ../../.yarn/cache/@smithy-config-resolver-npm-4.1.3-08af992379-6ec52e1609.zip/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseFipsEndpointConfigOptions.js
-var ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT";
-var CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint";
-var NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => booleanSelector(env2, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
-  configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
-  default: false
-};
-
-// ../../.yarn/cache/@smithy-config-resolver-npm-4.1.3-08af992379-6ec52e1609.zip/node_modules/@smithy/config-resolver/dist-es/regionConfig/config.js
-var REGION_ENV_NAME = "AWS_REGION";
-var REGION_INI_NAME = "region";
-var NODE_REGION_CONFIG_OPTIONS = {
-  environmentVariableSelector: (env2) => env2[REGION_ENV_NAME],
-  configFileSelector: (profile) => profile[REGION_INI_NAME],
-  default: () => {
-    throw new Error("Region is missing");
-  }
-};
-var NODE_REGION_CONFIG_FILE_OPTIONS = {
-  preferredFile: "credentials"
-};
-
-// ../../.yarn/cache/@smithy-middleware-content-length-npm-4.0.3-d15f97cd59-a212d89f23.zip/node_modules/@smithy/middleware-content-length/dist-es/index.js
+// ../../.yarn/cache/@smithy-middleware-content-length-npm-4.2.5-a18ec50ef8-672a29ab57.zip/node_modules/@smithy/middleware-content-length/dist-es/index.js
 var CONTENT_LENGTH_HEADER = "content-length";
 function contentLengthMiddleware(bodyLengthChecker) {
   return (next) => async (args) => {
@@ -2329,7 +4042,7 @@ var getContentLengthPlugin = (options) => ({
   }
 });
 
-// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.1.7-04a4311cd0-c3678a97d9.zip/node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/s3.js
+// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.3.12-0496a2b4e2-0bfb1d825d.zip/node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/s3.js
 var resolveParamsForS3 = async (endpointParams) => {
   const bucket = endpointParams?.Bucket || "";
   if (typeof endpointParams.Bucket === "string") {
@@ -2362,7 +4075,7 @@ var isArnBucketName = (bucketName) => {
   return isValidArn;
 };
 
-// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.1.7-04a4311cd0-c3678a97d9.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/createConfigValueProvider.js
+// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.3.12-0496a2b4e2-0bfb1d825d.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/createConfigValueProvider.js
 var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) => {
   const configProvider = async () => {
     const configValue = config[configKey] ?? config[canonicalEndpointParamKey];
@@ -2387,6 +4100,9 @@ var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) =
   }
   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) {
@@ -2403,7 +4119,7 @@ var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) =
   return configProvider;
 };
 
-// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.1.7-04a4311cd0-c3678a97d9.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointUrlConfig.js
+// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.3.12-0496a2b4e2-0bfb1d825d.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointUrlConfig.js
 var ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
 var CONFIG_ENDPOINT_URL = "endpoint_url";
 var getEndpointUrlConfig = (serviceId) => ({
@@ -2435,10 +4151,10 @@ var getEndpointUrlConfig = (serviceId) => ({
   default: void 0
 });
 
-// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.1.7-04a4311cd0-c3678a97d9.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromConfig.js
+// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.3.12-0496a2b4e2-0bfb1d825d.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromConfig.js
 var getEndpointFromConfig = async (serviceId) => loadConfig(getEndpointUrlConfig(serviceId ?? ""))();
 
-// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.1.7-04a4311cd0-c3678a97d9.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/toEndpointV1.js
+// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.3.12-0496a2b4e2-0bfb1d825d.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/toEndpointV1.js
 var toEndpointV1 = (endpoint) => {
   if (typeof endpoint === "object") {
     if ("url" in endpoint) {
@@ -2449,9 +4165,9 @@ var toEndpointV1 = (endpoint) => {
   return parseUrl(endpoint);
 };
 
-// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.1.7-04a4311cd0-c3678a97d9.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromInstructions.js
+// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.3.12-0496a2b4e2-0bfb1d825d.zip/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromInstructions.js
 var getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
-  if (!clientConfig.endpoint) {
+  if (!clientConfig.isCustomEndpoint) {
     let endpointFromConfig;
     if (clientConfig.serviceConfiguredEndpoint) {
       endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
@@ -2460,6 +4176,7 @@ var getEndpointFromInstructions = async (commandInput, instructionsSupplier, cli
     }
     if (endpointFromConfig) {
       clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
+      clientConfig.isCustomEndpoint = true;
     }
   }
   const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig);
@@ -2500,10 +4217,10 @@ var resolveParams = async (commandInput, instructionsSupplier, clientConfig) =>
   return endpointParams;
 };
 
-// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.1.7-04a4311cd0-c3678a97d9.zip/node_modules/@smithy/middleware-endpoint/dist-es/endpointMiddleware.js
+// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.3.12-0496a2b4e2-0bfb1d825d.zip/node_modules/@smithy/middleware-endpoint/dist-es/endpointMiddleware.js
 var endpointMiddleware = ({ config, instructions }) => {
   return (next, context) => async (args) => {
-    if (config.endpoint) {
+    if (config.isCustomEndpoint) {
       setFeature(context, "ENDPOINT_OVERRIDE", "N");
     }
     const endpoint = await getEndpointFromInstructions(args.input, {
@@ -2535,14 +4252,14 @@ var endpointMiddleware = ({ config, instructions }) => {
   };
 };
 
-// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.1.7-04a4311cd0-c3678a97d9.zip/node_modules/@smithy/middleware-endpoint/dist-es/getEndpointPlugin.js
+// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.3.12-0496a2b4e2-0bfb1d825d.zip/node_modules/@smithy/middleware-endpoint/dist-es/getEndpointPlugin.js
 var endpointMiddlewareOptions = {
   step: "serialize",
   tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
   name: "endpointV2Middleware",
   override: true,
   relation: "before",
-  toMiddleware: serializerMiddlewareOption.name
+  toMiddleware: serializerMiddlewareOption2.name
 };
 var getEndpointPlugin = (config, instructions) => ({
   applyToStack: (clientStack) => {
@@ -2553,7 +4270,7 @@ var getEndpointPlugin = (config, instructions) => ({
   }
 });
 
-// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.1.7-04a4311cd0-c3678a97d9.zip/node_modules/@smithy/middleware-endpoint/dist-es/resolveEndpointConfig.js
+// ../../.yarn/cache/@smithy-middleware-endpoint-npm-4.3.12-0496a2b4e2-0bfb1d825d.zip/node_modules/@smithy/middleware-endpoint/dist-es/resolveEndpointConfig.js
 var resolveEndpointConfig = (input) => {
   const tls = input.tls ?? true;
   const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input;
@@ -2576,7 +4293,7 @@ var resolveEndpointConfig = (input) => {
   return resolvedConfig;
 };
 
-// ../../.yarn/cache/@smithy-util-retry-npm-4.0.4-8cb74135af-ef4dd318ec.zip/node_modules/@smithy/util-retry/dist-es/config.js
+// ../../.yarn/cache/@smithy-util-retry-npm-4.2.5-d589822ced-3b330df346.zip/node_modules/@smithy/util-retry/dist-es/config.js
 var RETRY_MODES;
 (function(RETRY_MODES2) {
   RETRY_MODES2["STANDARD"] = "standard";
@@ -2585,7 +4302,7 @@ var RETRY_MODES;
 var DEFAULT_MAX_ATTEMPTS = 3;
 var DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
 
-// ../../.yarn/cache/@smithy-service-error-classification-npm-4.0.4-3aa7ae5563-06d6db4d88.zip/node_modules/@smithy/service-error-classification/dist-es/constants.js
+// ../../.yarn/cache/@smithy-service-error-classification-npm-4.2.5-12663503cb-d1a3ef99b4.zip/node_modules/@smithy/service-error-classification/dist-es/constants.js
 var THROTTLING_ERROR_CODES = [
   "BandwidthLimitExceeded",
   "EC2ThrottledException",
@@ -2605,8 +4322,10 @@ var THROTTLING_ERROR_CODES = [
 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"];
 
-// ../../.yarn/cache/@smithy-service-error-classification-npm-4.0.4-3aa7ae5563-06d6db4d88.zip/node_modules/@smithy/service-error-classification/dist-es/index.js
+// ../../.yarn/cache/@smithy-service-error-classification-npm-4.2.5-12663503cb-d1a3ef99b4.zip/node_modules/@smithy/service-error-classification/dist-es/index.js
+var isRetryableByTrait = (error) => error?.$retryable !== void 0;
 var isClockSkewCorrectedError = (error) => error.$metadata?.clockSkewCorrected;
 var isBrowserNetworkError = (error) => {
   const errorMessages = /* @__PURE__ */ new Set([
@@ -2623,7 +4342,7 @@ var isBrowserNetworkError = (error) => {
   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) => isClockSkewCorrectedError(error) || TRANSIENT_ERROR_CODES.includes(error.name) || NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") || TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) || isBrowserNetworkError(error) || error.cause !== void 0 && depth <= 10 && isTransientError(error.cause, depth + 1);
+var isTransientError = (error, depth = 0) => isRetryableByTrait(error) || isClockSkewCorrectedError(error) || TRANSIENT_ERROR_CODES.includes(error.name) || NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") || NODEJS_NETWORK_ERROR_CODES.includes(error?.code || "") || TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) || isBrowserNetworkError(error) || error.cause !== void 0 && depth <= 10 && isTransientError(error.cause, depth + 1);
 var isServerError = (error) => {
   if (error.$metadata?.httpStatusCode !== void 0) {
     const statusCode = error.$metadata.httpStatusCode;
@@ -2635,16 +4354,26 @@ var isServerError = (error) => {
   return false;
 };
 
-// ../../.yarn/cache/@smithy-util-retry-npm-4.0.4-8cb74135af-ef4dd318ec.zip/node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js
+// ../../.yarn/cache/@smithy-util-retry-npm-4.2.5-d589822ced-3b330df346.zip/node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js
 var DefaultRateLimiter = class _DefaultRateLimiter {
+  static setTimeoutFn = setTimeout;
+  beta;
+  minCapacity;
+  minFillRate;
+  scaleConstant;
+  smooth;
+  currentCapacity = 0;
+  enabled = false;
+  lastMaxRate = 0;
+  measuredTxRate = 0;
+  requestCount = 0;
+  fillRate;
+  lastThrottleTime;
+  lastTimestamp = 0;
+  lastTxRateBucket;
+  maxCapacity;
+  timeWindow = 0;
   constructor(options) {
-    this.currentCapacity = 0;
-    this.enabled = false;
-    this.lastMaxRate = 0;
-    this.measuredTxRate = 0;
-    this.requestCount = 0;
-    this.lastTimestamp = 0;
-    this.timeWindow = 0;
     this.beta = options?.beta ?? 0.7;
     this.minCapacity = options?.minCapacity ?? 1;
     this.minFillRate = options?.minFillRate ?? 0.5;
@@ -2733,9 +4462,8 @@ var DefaultRateLimiter = class _DefaultRateLimiter {
     return parseFloat(num.toFixed(8));
   }
 };
-DefaultRateLimiter.setTimeoutFn = setTimeout;
 
-// ../../.yarn/cache/@smithy-util-retry-npm-4.0.4-8cb74135af-ef4dd318ec.zip/node_modules/@smithy/util-retry/dist-es/constants.js
+// ../../.yarn/cache/@smithy-util-retry-npm-4.2.5-d589822ced-3b330df346.zip/node_modules/@smithy/util-retry/dist-es/constants.js
 var DEFAULT_RETRY_DELAY_BASE = 100;
 var MAXIMUM_RETRY_DELAY = 20 * 1e3;
 var THROTTLING_RETRY_DELAY_BASE = 500;
@@ -2746,7 +4474,7 @@ var NO_RETRY_INCREMENT = 1;
 var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
 var REQUEST_HEADER = "amz-sdk-request";
 
-// ../../.yarn/cache/@smithy-util-retry-npm-4.0.4-8cb74135af-ef4dd318ec.zip/node_modules/@smithy/util-retry/dist-es/defaultRetryBackoffStrategy.js
+// ../../.yarn/cache/@smithy-util-retry-npm-4.2.5-d589822ced-3b330df346.zip/node_modules/@smithy/util-retry/dist-es/defaultRetryBackoffStrategy.js
 var getDefaultRetryBackoffStrategy = () => {
   let delayBase = DEFAULT_RETRY_DELAY_BASE;
   const computeNextBackoffDelay = (attempts) => {
@@ -2761,7 +4489,7 @@ var getDefaultRetryBackoffStrategy = () => {
   };
 };
 
-// ../../.yarn/cache/@smithy-util-retry-npm-4.0.4-8cb74135af-ef4dd318ec.zip/node_modules/@smithy/util-retry/dist-es/defaultRetryToken.js
+// ../../.yarn/cache/@smithy-util-retry-npm-4.2.5-d589822ced-3b330df346.zip/node_modules/@smithy/util-retry/dist-es/defaultRetryToken.js
 var createDefaultRetryToken = ({ retryDelay, retryCount, retryCost }) => {
   const getRetryCount = () => retryCount;
   const getRetryDelay = () => Math.min(MAXIMUM_RETRY_DELAY, retryDelay);
@@ -2773,13 +4501,15 @@ var createDefaultRetryToken = ({ retryDelay, retryCount, retryCost }) => {
   };
 };
 
-// ../../.yarn/cache/@smithy-util-retry-npm-4.0.4-8cb74135af-ef4dd318ec.zip/node_modules/@smithy/util-retry/dist-es/StandardRetryStrategy.js
+// ../../.yarn/cache/@smithy-util-retry-npm-4.2.5-d589822ced-3b330df346.zip/node_modules/@smithy/util-retry/dist-es/StandardRetryStrategy.js
 var StandardRetryStrategy = class {
+  maxAttempts;
+  mode = RETRY_MODES.STANDARD;
+  capacity = INITIAL_RETRY_TOKENS;
+  retryBackoffStrategy = getDefaultRetryBackoffStrategy();
+  maxAttemptsProvider;
   constructor(maxAttempts) {
     this.maxAttempts = maxAttempts;
-    this.mode = RETRY_MODES.STANDARD;
-    this.capacity = INITIAL_RETRY_TOKENS;
-    this.retryBackoffStrategy = getDefaultRetryBackoffStrategy();
     this.maxAttemptsProvider = typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts;
   }
   async acquireInitialRetryToken(retryTokenScope) {
@@ -2831,11 +4561,14 @@ var StandardRetryStrategy = class {
   }
 };
 
-// ../../.yarn/cache/@smithy-util-retry-npm-4.0.4-8cb74135af-ef4dd318ec.zip/node_modules/@smithy/util-retry/dist-es/AdaptiveRetryStrategy.js
+// ../../.yarn/cache/@smithy-util-retry-npm-4.2.5-d589822ced-3b330df346.zip/node_modules/@smithy/util-retry/dist-es/AdaptiveRetryStrategy.js
 var AdaptiveRetryStrategy = class {
+  maxAttemptsProvider;
+  rateLimiter;
+  standardRetryStrategy;
+  mode = RETRY_MODES.ADAPTIVE;
   constructor(maxAttemptsProvider, options) {
     this.maxAttemptsProvider = maxAttemptsProvider;
-    this.mode = RETRY_MODES.ADAPTIVE;
     const { rateLimiter } = options ?? {};
     this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
     this.standardRetryStrategy = new StandardRetryStrategy(maxAttemptsProvider);
@@ -2854,7 +4587,7 @@ var AdaptiveRetryStrategy = class {
   }
 };
 
-// ../../.yarn/cache/@smithy-middleware-retry-npm-4.1.8-d97de21375-bed41045a3.zip/node_modules/@smithy/middleware-retry/dist-es/configurations.js
+// ../../.yarn/cache/@smithy-middleware-retry-npm-4.4.12-84978bdff8-3c958a58c6.zip/node_modules/@smithy/middleware-retry/dist-es/configurations.js
 var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
 var CONFIG_MAX_ATTEMPTS = "max_attempts";
 var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
@@ -2905,58 +4638,11 @@ var NODE_RETRY_MODE_CONFIG_OPTIONS = {
   default: DEFAULT_RETRY_MODE
 };
 
-// ../../.yarn/cache/uuid-npm-9.0.1-39a8442bc6-1607dd32ac.zip/node_modules/uuid/dist/esm-node/rng.js
-import crypto from "crypto";
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    crypto.randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// ../../.yarn/cache/uuid-npm-9.0.1-39a8442bc6-1607dd32ac.zip/node_modules/uuid/dist/esm-node/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
-}
-
-// ../../.yarn/cache/uuid-npm-9.0.1-39a8442bc6-1607dd32ac.zip/node_modules/uuid/dist/esm-node/native.js
-import crypto2 from "crypto";
-var native_default = {
-  randomUUID: crypto2.randomUUID
-};
-
-// ../../.yarn/cache/uuid-npm-9.0.1-39a8442bc6-1607dd32ac.zip/node_modules/uuid/dist/esm-node/v4.js
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
-  options = options || {};
-  const rnds = options.random || (options.rng || rng)();
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-var v4_default = v4;
-
-// ../../.yarn/cache/@smithy-middleware-retry-npm-4.1.8-d97de21375-bed41045a3.zip/node_modules/@smithy/middleware-retry/dist-es/isStreamingPayload/isStreamingPayload.js
+// ../../.yarn/cache/@smithy-middleware-retry-npm-4.4.12-84978bdff8-3c958a58c6.zip/node_modules/@smithy/middleware-retry/dist-es/isStreamingPayload/isStreamingPayload.js
 import { Readable } from "stream";
 var isStreamingPayload = (request) => request?.body instanceof Readable || typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream;
 
-// ../../.yarn/cache/@smithy-middleware-retry-npm-4.1.8-d97de21375-bed41045a3.zip/node_modules/@smithy/middleware-retry/dist-es/util.js
+// ../../.yarn/cache/@smithy-middleware-retry-npm-4.4.12-84978bdff8-3c958a58c6.zip/node_modules/@smithy/middleware-retry/dist-es/util.js
 var asSdkError = (error) => {
   if (error instanceof Error)
     return error;
@@ -2967,7 +4653,7 @@ var asSdkError = (error) => {
   return new Error(`AWS SDK error wrapper for ${error}`);
 };
 
-// ../../.yarn/cache/@smithy-middleware-retry-npm-4.1.8-d97de21375-bed41045a3.zip/node_modules/@smithy/middleware-retry/dist-es/retryMiddleware.js
+// ../../.yarn/cache/@smithy-middleware-retry-npm-4.4.12-84978bdff8-3c958a58c6.zip/node_modules/@smithy/middleware-retry/dist-es/retryMiddleware.js
 var retryMiddleware = (options) => (next, context) => async (args) => {
   let retryStrategy = await options.retryStrategy();
   const maxAttempts = await options.maxAttempts();
@@ -2980,7 +4666,7 @@ var retryMiddleware = (options) => (next, context) => async (args) => {
     const { request } = args;
     const isRequest = HttpRequest.isInstance(request);
     if (isRequest) {
-      request.headers[INVOCATION_ID_HEADER] = v4_default();
+      request.headers[INVOCATION_ID_HEADER] = v4();
     }
     while (true) {
       try {
@@ -3069,16 +4755,66 @@ var getRetryAfterHint = (response) => {
   return retryAfterDate;
 };
 
-// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-d7c5be5d47/0/cache/@aws-sdk-util-user-agent-node-npm-3.816.0-fd0f8bc4b3-199f89c9de.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/defaultUserAgent.js
+// ../../.yarn/cache/@smithy-util-config-provider-npm-4.2.0-2db64d7c7a-0699b9980e.zip/node_modules/@smithy/util-config-provider/dist-es/booleanSelector.js
+var booleanSelector = (obj, key, type) => {
+  if (!(key in obj))
+    return void 0;
+  if (obj[key] === "true")
+    return true;
+  if (obj[key] === "false")
+    return false;
+  throw new Error(`Cannot load ${type} "${key}". Expected "true" or "false", got ${obj[key]}.`);
+};
+
+// ../../.yarn/cache/@smithy-util-config-provider-npm-4.2.0-2db64d7c7a-0699b9980e.zip/node_modules/@smithy/util-config-provider/dist-es/types.js
+var SelectorType;
+(function(SelectorType2) {
+  SelectorType2["ENV"] = "env";
+  SelectorType2["CONFIG"] = "shared config entry";
+})(SelectorType || (SelectorType = {}));
+
+// ../../.yarn/cache/@smithy-config-resolver-npm-4.4.3-995b58e856-e28844ea32.zip/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseDualstackEndpointConfigOptions.js
+var ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
+var CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
+var NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env2) => booleanSelector(env2, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
+  configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
+  default: false
+};
+
+// ../../.yarn/cache/@smithy-config-resolver-npm-4.4.3-995b58e856-e28844ea32.zip/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseFipsEndpointConfigOptions.js
+var ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT";
+var CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint";
+var NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env2) => booleanSelector(env2, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
+  configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
+  default: false
+};
+
+// ../../.yarn/cache/@smithy-config-resolver-npm-4.4.3-995b58e856-e28844ea32.zip/node_modules/@smithy/config-resolver/dist-es/regionConfig/config.js
+var REGION_ENV_NAME = "AWS_REGION";
+var REGION_INI_NAME = "region";
+var NODE_REGION_CONFIG_OPTIONS = {
+  environmentVariableSelector: (env2) => env2[REGION_ENV_NAME],
+  configFileSelector: (profile) => profile[REGION_INI_NAME],
+  default: () => {
+    throw new Error("Region is missing");
+  }
+};
+var NODE_REGION_CONFIG_FILE_OPTIONS = {
+  preferredFile: "credentials"
+};
+
+// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-53d8ac5a0c/0/cache/@aws-sdk-util-user-agent-node-npm-3.940.0-1053e573db-0287c87d3e.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/defaultUserAgent.js
 import { platform, release } from "os";
 import { env, versions } from "process";
 
-// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-d7c5be5d47/0/cache/@aws-sdk-util-user-agent-node-npm-3.816.0-fd0f8bc4b3-199f89c9de.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/crt-availability.js
+// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-53d8ac5a0c/0/cache/@aws-sdk-util-user-agent-node-npm-3.940.0-1053e573db-0287c87d3e.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/crt-availability.js
 var crtAvailability = {
   isCrtAvailable: false
 };
 
-// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-d7c5be5d47/0/cache/@aws-sdk-util-user-agent-node-npm-3.816.0-fd0f8bc4b3-199f89c9de.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/is-crt-available.js
+// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-53d8ac5a0c/0/cache/@aws-sdk-util-user-agent-node-npm-3.940.0-1053e573db-0287c87d3e.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/is-crt-available.js
 var isCrtAvailable = () => {
   if (crtAvailability.isCrtAvailable) {
     return ["md/crt-avail"];
@@ -3086,7 +4822,7 @@ var isCrtAvailable = () => {
   return null;
 };
 
-// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-d7c5be5d47/0/cache/@aws-sdk-util-user-agent-node-npm-3.816.0-fd0f8bc4b3-199f89c9de.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/defaultUserAgent.js
+// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-53d8ac5a0c/0/cache/@aws-sdk-util-user-agent-node-npm-3.940.0-1053e573db-0287c87d3e.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/defaultUserAgent.js
 var createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
   return async (config) => {
     const sections = [
@@ -3112,7 +4848,7 @@ var createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
   };
 };
 
-// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-d7c5be5d47/0/cache/@aws-sdk-util-user-agent-node-npm-3.816.0-fd0f8bc4b3-199f89c9de.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/nodeAppIdConfigOptions.js
+// ../../.yarn/__virtual__/@aws-sdk-util-user-agent-node-virtual-53d8ac5a0c/0/cache/@aws-sdk-util-user-agent-node-npm-3.940.0-1053e573db-0287c87d3e.zip/node_modules/@aws-sdk/util-user-agent-node/dist-es/nodeAppIdConfigOptions.js
 var UA_APP_ID_ENV_NAME = "AWS_SDK_UA_APP_ID";
 var UA_APP_ID_INI_NAME = "sdk_ua_app_id";
 var UA_APP_ID_INI_NAME_DEPRECATED = "sdk-ua-app-id";
@@ -3122,10 +4858,13 @@ var NODE_APP_ID_CONFIG_OPTIONS = {
   default: DEFAULT_UA_APP_ID
 };
 
-// ../../.yarn/cache/@smithy-hash-node-npm-4.0.3-ac40e4abd9-ce48452828.zip/node_modules/@smithy/hash-node/dist-es/index.js
+// ../../.yarn/cache/@smithy-hash-node-npm-4.2.5-b32ea95a0a-e0c24b8b93.zip/node_modules/@smithy/hash-node/dist-es/index.js
 import { Buffer as Buffer2 } from "buffer";
 import { createHash, createHmac } from "crypto";
 var Hash = class {
+  algorithmIdentifier;
+  secret;
+  hash;
   constructor(algorithmIdentifier, secret) {
     this.algorithmIdentifier = algorithmIdentifier;
     this.secret = secret;
@@ -3154,8 +4893,8 @@ function castSourceData(toCast, encoding) {
   return fromArrayBuffer(toCast);
 }
 
-// ../../.yarn/cache/@smithy-util-body-length-node-npm-4.0.0-a7afbc8cd6-e91fd38167.zip/node_modules/@smithy/util-body-length-node/dist-es/calculateBodyLength.js
-import { fstatSync, lstatSync } from "fs";
+// ../../.yarn/cache/@smithy-util-body-length-node-npm-4.2.1-c885ec7ad4-3c32306735.zip/node_modules/@smithy/util-body-length-node/dist-es/calculateBodyLength.js
+import { fstatSync, lstatSync, ReadStream } from "fs";
 var calculateBodyLength = (body) => {
   if (!body) {
     return 0;
@@ -3168,15 +4907,17 @@ var calculateBodyLength = (body) => {
     return body.size;
   } else if (typeof body.start === "number" && typeof body.end === "number") {
     return body.end + 1 - body.start;
-  } else if (typeof body.path === "string" || Buffer.isBuffer(body.path)) {
-    return lstatSync(body.path).size;
-  } else if (typeof body.fd === "number") {
-    return fstatSync(body.fd).size;
+  } else if (body instanceof ReadStream) {
+    if (body.path != null) {
+      return lstatSync(body.path).size;
+    } else if (typeof body.fd === "number") {
+      return fstatSync(body.fd).size;
+    }
   }
   throw new Error(`Body Length computation failed for ${body}`);
 };
 
-// ../../.yarn/cache/@smithy-util-defaults-mode-node-npm-4.0.15-b4c74611bb-c20fa407b1.zip/node_modules/@smithy/util-defaults-mode-node/dist-es/constants.js
+// ../../.yarn/cache/@smithy-util-defaults-mode-node-npm-4.2.14-97d242f937-965860eddf.zip/node_modules/@smithy/util-defaults-mode-node/dist-es/constants.js
 var AWS_EXECUTION_ENV = "AWS_EXECUTION_ENV";
 var AWS_REGION_ENV = "AWS_REGION";
 var AWS_DEFAULT_REGION_ENV = "AWS_DEFAULT_REGION";
@@ -3184,7 +4925,7 @@ var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
 var DEFAULTS_MODE_OPTIONS = ["in-region", "cross-region", "mobile", "standard", "legacy"];
 var IMDS_REGION_PATH = "/latest/meta-data/placement/region";
 
-// ../../.yarn/cache/@smithy-util-defaults-mode-node-npm-4.0.15-b4c74611bb-c20fa407b1.zip/node_modules/@smithy/util-defaults-mode-node/dist-es/defaultsModeConfig.js
+// ../../.yarn/cache/@smithy-util-defaults-mode-node-npm-4.2.14-97d242f937-965860eddf.zip/node_modules/@smithy/util-defaults-mode-node/dist-es/defaultsModeConfig.js
 var AWS_DEFAULTS_MODE_ENV = "AWS_DEFAULTS_MODE";
 var AWS_DEFAULTS_MODE_CONFIG = "defaults_mode";
 var NODE_DEFAULTS_MODE_CONFIG_OPTIONS = {
@@ -3197,7 +4938,7 @@ var NODE_DEFAULTS_MODE_CONFIG_OPTIONS = {
   default: "legacy"
 };
 
-// ../../.yarn/cache/@smithy-util-defaults-mode-node-npm-4.0.15-b4c74611bb-c20fa407b1.zip/node_modules/@smithy/util-defaults-mode-node/dist-es/resolveDefaultsModeConfig.js
+// ../../.yarn/cache/@smithy-util-defaults-mode-node-npm-4.2.14-97d242f937-965860eddf.zip/node_modules/@smithy/util-defaults-mode-node/dist-es/resolveDefaultsModeConfig.js
 var resolveDefaultsModeConfig = ({ region = loadConfig(NODE_REGION_CONFIG_OPTIONS), defaultsMode = loadConfig(NODE_DEFAULTS_MODE_CONFIG_OPTIONS) } = {}) => memoize(async () => {
   const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode;
   switch (mode?.toLowerCase()) {
@@ -3236,7 +4977,7 @@ var inferPhysicalRegion = async () => {
   }
   if (!process.env[ENV_IMDS_DISABLED]) {
     try {
-      const { getInstanceMetadataEndpoint, httpRequest } = await import("./dist-es-GHYMLBON.js");
+      const { getInstanceMetadataEndpoint, httpRequest } = await import("./dist-es-HSWXMGNC.js");
       const endpoint = await getInstanceMetadataEndpoint();
       return (await httpRequest({ ...endpoint, path: IMDS_REGION_PATH })).toString();
     } catch (e) {
@@ -3244,7 +4985,7 @@ var inferPhysicalRegion = async () => {
   }
 };
 
-// ../../.yarn/cache/@aws-sdk-region-config-resolver-npm-3.808.0-fa9d95c7c8-3e21dcf467.zip/node_modules/@aws-sdk/region-config-resolver/dist-es/extensions/index.js
+// ../../.yarn/cache/@aws-sdk-region-config-resolver-npm-3.936.0-ac429a151d-67ecf8f357.zip/node_modules/@aws-sdk/region-config-resolver/dist-es/extensions/index.js
 var getAwsRegionExtensionConfiguration = (runtimeConfig) => {
   return {
     setRegion(region) {
@@ -3262,6 +5003,8 @@ var resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) =
 };
 
 export {
+  getHttpHandlerExtensionConfiguration,
+  resolveHttpHandlerRuntimeConfig,
   resolveHostHeaderConfig,
   getHostHeaderPlugin,
   getLoggerPlugin,
@@ -3269,10 +5012,23 @@ export {
   getSmithyContext,
   normalizeProvider,
   getHttpAuthSchemeEndpointRuleSetPlugin,
-  getSerdePlugin,
   getHttpSigningPlugin,
+  collectBody,
+  extendedEncodeURIComponent,
+  deref,
+  getSchemaSerdePlugin,
+  translateTraits,
+  NormalizedSchema,
+  TypeRegistry,
+  v4,
+  LazyJsonString,
+  splitHeader,
+  NumericValue,
+  SerdeContext,
+  HttpProtocol,
+  determineTimestampFormat,
+  FromStringShapeDeserializer,
   DefaultIdentityProviderConfig,
-  NoAuthSigner,
   resolveUserAgentConfig,
   EndpointCache,
   customEndpointFunctions,
@@ -3282,7 +5038,18 @@ export {
   AwsSdkSigV4Signer,
   NODE_AUTH_SCHEME_PREFERENCE_OPTIONS,
   resolveAwsSdkSigV4Config,
-  collectBodyString,
+  Client,
+  Command,
+  ServiceException,
+  loadConfigsForDefaultMode,
+  emitWarningIfUnsupportedVersion2,
+  getDefaultExtensionConfiguration,
+  resolveDefaultRuntimeConfig,
+  NoOpLogger,
+  ProtocolLib,
+  SerdeContextConfig,
+  serializingStructIterator,
+  deserializingStructIterator,
   getUserAgentPlugin,
   NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS,
   NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS,