@granite-js/pulumi-aws 0.1.34 → 1.0.1

package/dist/{chunk-QAE2S7MG.js → chunk-7NN7DVGK.js}

@@ -1,148 +1,421 @@
 import {
   loadConfig,
+  memoize,
   parseUrl
-} from "./chunk-X6XO7USX.js";
+} from "./chunk-63Q3RLAK.js";
+import {
+  CONFIG_PREFIX_SEPARATOR
+} from "./chunk-GJFKL6XM.js";
 import {
-  HttpRequest,
   HttpResponse,
-  NoOpLogger,
-  collectBody,
   escapeUri,
-  fromArrayBuffer,
+  fromBase64,
   fromHex,
-  fromString,
-  fromUtf8,
-  isArrayBuffer,
-  toHex,
-  toUint8Array
-} from "./chunk-UT2RMOJS.js";
+  toBase64,
+  toHex
+} from "./chunk-57WYIP4I.js";
 import {
-  CONFIG_PREFIX_SEPARATOR
-} from "./chunk-TJ744C2T.js";
+  HttpRequest
+} from "./chunk-TDZTH7TL.js";
 import {
   setCredentialFeature
-} from "./chunk-64IS37V6.js";
+} from "./chunk-RYIGWCGK.js";
 import {
-  EndpointURLScheme,
-  SMITHY_CONTEXT_KEY
-} from "./chunk-XLUI7RQ4.js";
+  fromArrayBuffer,
+  fromString,
+  fromUtf8,
+  isArrayBuffer,
+  toUtf8
+} from "./chunk-H4QJ5O4E.js";
 import {
-  ProviderError,
-  init_esm_shims,
-  memoize
-} from "./chunk-JBVMOFGH.js";
+  ProviderError
+} from "./chunk-THUA35UY.js";
 
-// ../deployment-manager/dist/chunk-N74WAUXR.js
-import crypto from "crypto";
+// ../deployment-manager/dist/chunk-IF7J7OTC.js
 import crypto2 from "crypto";
 import { Readable } from "stream";
 import { platform, release } from "os";
 import { env, versions } from "process";
 import { Buffer as Buffer2 } from "buffer";
 import { createHash, createHmac } from "crypto";
-import { fstatSync, lstatSync } from "fs";
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-var getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
-init_esm_shims();
-var normalizeProvider = (input) => {
-  if (typeof input === "function")
-    return input;
-  const promisified = Promise.resolve(input);
-  return () => promisified;
-};
-init_esm_shims();
-var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
-  if (!authSchemePreference || authSchemePreference.length === 0) {
-    return candidateAuthOptions;
-  }
-  const preferredAuthOptions = [];
-  for (const preferredSchemeName of authSchemePreference) {
-    for (const candidateAuthOption of candidateAuthOptions) {
-      const candidateAuthSchemeName = candidateAuthOption.schemeId.split("#")[1];
-      if (candidateAuthSchemeName === preferredSchemeName) {
-        preferredAuthOptions.push(candidateAuthOption);
-      }
+import { fstatSync, lstatSync, ReadStream } from "fs";
+var getAllAliases = (name, aliases) => {
+  const _aliases = [];
+  if (name) {
+    _aliases.push(name);
+  }
+  if (aliases) {
+    for (const alias of aliases) {
+      _aliases.push(alias);
     }
   }
-  for (const candidateAuthOption of candidateAuthOptions) {
-    if (!preferredAuthOptions.find(({ schemeId }) => schemeId === candidateAuthOption.schemeId)) {
-      preferredAuthOptions.push(candidateAuthOption);
+  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 preferredAuthOptions;
+  };
+  return stack;
 };
-function convertHttpAuthSchemesToMap(httpAuthSchemes) {
-  const map = /* @__PURE__ */ new Map();
-  for (const scheme of httpAuthSchemes) {
-    map.set(scheme.schemeId, scheme);
-  }
-  return map;
-}
-var httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => {
-  const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input));
-  const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
-  const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
-  const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
-  const smithyContext = getSmithyContext(context);
-  const failureReasons = [];
-  for (const option of resolvedOptions) {
-    const scheme = authSchemes.get(option.schemeId);
-    if (!scheme) {
-      failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`);
-      continue;
+var stepWeights = {
+  initialize: 5,
+  serialize: 4,
+  build: 3,
+  finalizeRequest: 2,
+  deserialize: 1
+};
+var priorityWeights = {
+  high: 3,
+  normal: 2,
+  low: 1
+};
+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);
     }
-    const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config));
-    if (!identityProvider) {
-      failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`);
-      continue;
+    if (callback) {
+      handler(command).then((result) => callback(null, result.output), (err) => callback(err)).catch(() => {
+      });
+    } else {
+      return handler(command).then((result) => result.output);
     }
-    const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {};
-    option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties);
-    option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties);
-    smithyContext.selectedHttpAuthScheme = {
-      httpAuthOption: option,
-      identity: await identityProvider(option.identityProperties),
-      signer: scheme.signer
-    };
-    break;
   }
-  if (!smithyContext.selectedHttpAuthScheme) {
-    throw new Error(failureReasons.join("\n"));
+  destroy() {
+    this.config?.requestHandler?.destroy?.();
+    delete this.handlers;
   }
-  return next(args);
 };
-var httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
-  step: "serialize",
-  tags: ["HTTP_AUTH_SCHEME"],
-  name: "httpAuthSchemeMiddleware",
-  override: true,
-  relation: "before",
-  toMiddleware: "endpointV2Middleware"
+var EndpointURLScheme;
+(function(EndpointURLScheme2) {
+  EndpointURLScheme2["HTTP"] = "http";
+  EndpointURLScheme2["HTTPS"] = "https";
+})(EndpointURLScheme || (EndpointURLScheme = {}));
+var AlgorithmId;
+(function(AlgorithmId2) {
+  AlgorithmId2["MD5"] = "md5";
+  AlgorithmId2["CRC32"] = "crc32";
+  AlgorithmId2["CRC32C"] = "crc32c";
+  AlgorithmId2["SHA1"] = "sha1";
+  AlgorithmId2["SHA256"] = "sha256";
+})(AlgorithmId || (AlgorithmId = {}));
+var SMITHY_CONTEXT_KEY = "__smithy_context";
+var deref = (schemaRef) => {
+  if (typeof schemaRef === "function") {
+    return schemaRef();
+  }
+  return schemaRef;
 };
-var getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
-  applyToStack: (clientStack) => {
-    clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
-      httpAuthSchemeParametersProvider,
-      identityProviderConfigProvider
-    }), httpAuthSchemeEndpointRuleSetMiddlewareOptions);
-  }
+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()
+  };
+};
+var getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
+var normalizeProvider = (input) => {
+  if (typeof input === "function")
+    return input;
+  const promisified = Promise.resolve(input);
+  return () => promisified;
+};
+var operation = (namespace, name, traits, input, output) => ({
+  name,
+  namespace,
+  traits,
+  input,
+  output
 });
-init_esm_shims();
-init_esm_shims();
-var deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
+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 deserializer(response, options);
+    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
+      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.`;
@@ -174,50 +447,596 @@ var deserializerMiddleware = (options, deserializer) => (next, context) => async
       } catch (e) {
       }
     }
-    throw error;
+    throw error;
+  }
+};
+var findHeader = (pattern, headers) => {
+  return (headers.find(([k]) => {
+    return k.match(pattern);
+  }) || [void 0, void 0])[1];
+};
+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
+  });
+};
+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);
+    }
+  };
+}
+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;
+}
+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;
+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;
+  }
+};
+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;
+}
+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;
+    };
+  }
+};
+var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
+  if (!authSchemePreference || authSchemePreference.length === 0) {
+    return candidateAuthOptions;
+  }
+  const preferredAuthOptions = [];
+  for (const preferredSchemeName of authSchemePreference) {
+    for (const candidateAuthOption of candidateAuthOptions) {
+      const candidateAuthSchemeName = candidateAuthOption.schemeId.split("#")[1];
+      if (candidateAuthSchemeName === preferredSchemeName) {
+        preferredAuthOptions.push(candidateAuthOption);
+      }
+    }
+  }
+  for (const candidateAuthOption of candidateAuthOptions) {
+    if (!preferredAuthOptions.find(({ schemeId }) => schemeId === candidateAuthOption.schemeId)) {
+      preferredAuthOptions.push(candidateAuthOption);
+    }
+  }
+  return preferredAuthOptions;
+};
+function convertHttpAuthSchemesToMap(httpAuthSchemes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const scheme of httpAuthSchemes) {
+    map.set(scheme.schemeId, scheme);
+  }
+  return map;
+}
+var httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => {
+  const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input));
+  const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
+  const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
+  const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
+  const smithyContext = getSmithyContext(context);
+  const failureReasons = [];
+  for (const option of resolvedOptions) {
+    const scheme = authSchemes.get(option.schemeId);
+    if (!scheme) {
+      failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`);
+      continue;
+    }
+    const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config));
+    if (!identityProvider) {
+      failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`);
+      continue;
+    }
+    const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {};
+    option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties);
+    option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties);
+    smithyContext.selectedHttpAuthScheme = {
+      httpAuthOption: option,
+      identity: await identityProvider(option.identityProperties),
+      signer: scheme.signer
+    };
+    break;
   }
-};
-var findHeader = (pattern, headers) => {
-  return (headers.find(([k]) => {
-    return k.match(pattern);
-  }) || [void 0, void 0])[1];
-};
-init_esm_shims();
-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.");
+  if (!smithyContext.selectedHttpAuthScheme) {
+    throw new Error(failureReasons.join("\n"));
   }
-  const request = await serializer(args.input, { ...options, endpoint });
-  return next({
-    ...args,
-    request
-  });
-};
-var deserializerMiddlewareOption = {
-  name: "deserializerMiddleware",
-  step: "deserialize",
-  tags: ["DESERIALIZER"],
-  override: true
+  return next(args);
 };
-var serializerMiddlewareOption = {
-  name: "serializerMiddleware",
+var httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
   step: "serialize",
-  tags: ["SERIALIZER"],
-  override: true
+  tags: ["HTTP_AUTH_SCHEME"],
+  name: "httpAuthSchemeMiddleware",
+  override: true,
+  relation: "before",
+  toMiddleware: "endpointV2Middleware"
 };
-function getSerdePlugin(config, serializer, deserializer) {
-  return {
-    applyToStack: (commandStack) => {
-      commandStack.add(deserializerMiddleware(config, deserializer), deserializerMiddlewareOption);
-      commandStack.add(serializerMiddleware(config, serializer), serializerMiddlewareOption);
-    }
-  };
-}
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
+var getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
+  applyToStack: (clientStack) => {
+    clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
+      httpAuthSchemeParametersProvider,
+      identityProviderConfigProvider
+    }), httpAuthSchemeEndpointRuleSetMiddlewareOptions);
+  }
+});
 var defaultErrorHandler = (signingProperties) => (error) => {
   throw error;
 };
@@ -254,7 +1073,6 @@ var getHttpSigningPlugin = (config) => ({
     clientStack.addRelativeTo(httpSigningMiddleware(config), httpSigningMiddlewareOptions);
   }
 });
-init_esm_shims();
 var makePagedClientRequest = async (CommandCtor, client, input, withCommand = (_) => _, ...args) => {
   let command = new CommandCtor(input);
   command = withCommand(command) ?? command;
@@ -295,10 +1113,9 @@ var get = (fromObject, path) => {
   }
   return cursor;
 };
-init_esm_shims();
 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);
@@ -309,28 +1126,448 @@ var DefaultIdentityProviderConfig = class {
     return this.authSchemes.get(schemeId);
   }
 };
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-var httpAuthSchemeMiddlewareOptions = {
+var serializerMiddlewareOption2 = {
+  name: "serializerMiddleware",
   step: "serialize",
-  tags: ["HTTP_AUTH_SCHEME"],
-  name: "httpAuthSchemeMiddleware",
-  override: true,
-  relation: "before",
-  toMiddleware: serializerMiddlewareOption.name
+  tags: ["SERIALIZER"],
+  override: true
 };
-init_esm_shims();
-init_esm_shims();
 var normalizeProvider2 = (input) => {
   if (typeof input === "function")
     return input;
   const promisified = Promise.resolve(input);
   return () => promisified;
 };
-init_esm_shims();
-init_esm_shims();
+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);
+};
+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);
+  }
+};
+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);
+};
+function extendedEncodeURIComponent(str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+  });
+}
+var randomUUID = crypto2.randomUUID.bind(crypto2);
+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]];
+};
+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;
+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}]`);
+  }
+}
+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, '"');
+  });
+};
+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);
+  }
+};
+var SerdeContext = class {
+  serdeContext;
+  setSerdeContext(serdeContext) {
+    this.serdeContext = serdeContext;
+  }
+};
+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-L7RH32OW-AFMBEYJJ.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;
+  }
+};
+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;
+}
+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));
+  }
+};
 function setFeature(context, feature, value) {
   if (!context.__smithy_context) {
     context.__smithy_context = {
@@ -341,18 +1578,14 @@ function setFeature(context, feature, value) {
   }
   context.__smithy_context.features[feature] = value;
 }
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var NoAuthSigner = class {
   async sign(httpRequest, identity, signingProperties) {
     return httpRequest;
   }
 };
-init_esm_shims();
-var createIsIdentityExpiredFunction = (expirationMs) => (identity) => doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
+var createIsIdentityExpiredFunction = (expirationMs) => function isIdentityExpired2(identity) {
+  return doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
+};
 var EXPIRATION_MS = 3e5;
 var isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
 var doesIdentityRequireRefresh = (identity) => identity.expiration !== void 0;
@@ -404,7 +1637,51 @@ var memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
     return resolved;
   };
 };
-init_esm_shims();
+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;
+};
 function resolveHostHeaderConfig(input) {
   return input;
 }
@@ -436,7 +1713,6 @@ var getHostHeaderPlugin = (options) => ({
     clientStack.add(hostHeaderMiddleware(options), hostHeaderMiddlewareOptions);
   }
 });
-init_esm_shims();
 var loggerMiddleware = () => (next, context) => async (args) => {
   try {
     const response = await next(args);
@@ -478,14 +1754,132 @@ var getLoggerPlugin = (options) => ({
     clientStack.add(loggerMiddleware(), loggerMiddlewareOptions);
   }
 });
-init_esm_shims();
-init_esm_shims();
+var recursionDetectionMiddlewareOptions = {
+  step: "build",
+  tags: ["RECURSION_DETECTION"],
+  name: "recursionDetectionMiddleware",
+  override: true,
+  priority: "low"
+};
+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 = {}));
 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;
@@ -493,7 +1887,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;
@@ -503,19 +1900,11 @@ var recursionDetectionMiddleware = (options) => (next) => async (args) => {
     request
   });
 };
-var addRecursionDetectionMiddlewareOptions = {
-  step: "build",
-  tags: ["RECURSION_DETECTION"],
-  name: "recursionDetectionMiddleware",
-  override: true,
-  priority: "low"
-};
 var getRecursionDetectionPlugin = (options) => ({
   applyToStack: (clientStack) => {
-    clientStack.add(recursionDetectionMiddleware(options), addRecursionDetectionMiddlewareOptions);
+    clientStack.add(recursionDetectionMiddleware(), recursionDetectionMiddlewareOptions);
   }
 });
-init_esm_shims();
 var DEFAULT_UA_APP_ID = void 0;
 function isValidUserAgentAppId(appId) {
   if (appId === void 0) {
@@ -542,15 +1931,11 @@ function resolveUserAgentConfig(input) {
     }
   });
 }
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 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;
@@ -596,10 +1981,8 @@ var EndpointCache = class {
     return buffer;
   }
 };
-init_esm_shims();
 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("]");
-init_esm_shims();
 var VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
 var isValidHostLabel = (value, allowSubDomains = false) => {
   if (!allowSubDomains) {
@@ -613,13 +1996,8 @@ var isValidHostLabel = (value, allowSubDomains = false) => {
   }
   return true;
 };
-init_esm_shims();
 var customEndpointFunctions = {};
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var debugId = "endpoints";
-init_esm_shims();
 function toDebugString(input) {
   if (typeof input !== "object" || input == null) {
     return input;
@@ -632,32 +2010,13 @@ function toDebugString(input) {
   }
   return JSON.stringify(input, null, 2);
 }
-init_esm_shims();
-init_esm_shims();
 var EndpointError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "EndpointError";
   }
 };
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var booleanEquals = (value1, value2) => value1 === value2;
-init_esm_shims();
-init_esm_shims();
 var getAttrPathList = (path) => {
   const parts = path.split(".");
   const pathList = [];
@@ -689,11 +2048,8 @@ var getAttr = (value, path) => getAttrPathList(path).reduce((acc, index) => {
   }
   return acc[index];
 }, value);
-init_esm_shims();
 var isSet = (value) => value != null;
-init_esm_shims();
 var not = (value) => !value;
-init_esm_shims();
 var DEFAULT_PORTS = {
   [EndpointURLScheme.HTTP]: 80,
   [EndpointURLScheme.HTTPS]: 443
@@ -739,9 +2095,7 @@ var parseURL = (value) => {
     isIp
   };
 };
-init_esm_shims();
 var stringEquals = (value1, value2) => value1 === value2;
-init_esm_shims();
 var substring = (input, start, stop, reverse) => {
   if (start >= stop || input.length < stop) {
     return null;
@@ -751,7 +2105,6 @@ var substring = (input, start, stop, reverse) => {
   }
   return input.substring(input.length - stop, input.length - start);
 };
-init_esm_shims();
 var uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
 var endpointFunctions = {
   booleanEquals,
@@ -764,8 +2117,6 @@ var endpointFunctions = {
   substring,
   uriEncode
 };
-init_esm_shims();
-init_esm_shims();
 var evaluateTemplate = (template, options) => {
   const evaluatedTemplateArr = [];
   const templateContext = {
@@ -800,7 +2151,6 @@ var evaluateTemplate = (template, options) => {
   }
   return evaluatedTemplateArr.join("");
 };
-init_esm_shims();
 var getReferenceValue = ({ ref }, options) => {
   const referenceRecord = {
     ...options.endpointParams,
@@ -812,20 +2162,24 @@ 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.`);
 };
 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
+};
 var evaluateCondition = ({ assign, ...fnArgs }, options) => {
   if (assign && assign in options.referenceRecord) {
     throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
@@ -857,7 +2211,6 @@ var evaluateConditions = (conditions = [], options) => {
   }
   return { result: true, referenceRecord: conditionsReferenceRecord };
 };
-init_esm_shims();
 var getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((acc, [headerKey, headerVal]) => ({
   ...acc,
   [headerKey]: headerVal.map((headerValEntry) => {
@@ -868,8 +2221,10 @@ var getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((a
     return processedExpr;
   })
 }), {});
-init_esm_shims();
-init_esm_shims();
+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));
@@ -881,18 +2236,17 @@ 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 getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
-  ...acc,
-  [propertyKey]: getEndpointProperty(propertyVal, options)
-}), {});
-init_esm_shims();
+var group2 = {
+  getEndpointProperty,
+  getEndpointProperties
+};
 var getEndpointUrl = (endpointUrl, options) => {
   const expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
   if (typeof expression === "string") {
@@ -927,7 +2281,6 @@ var evaluateEndpointRule = (endpointRule, options) => {
     url: getEndpointUrl(url, endpointRuleOptions)
   };
 };
-init_esm_shims();
 var evaluateErrorRule = (errorRule, options) => {
   const { conditions, error } = errorRule;
   const { result, referenceRecord } = evaluateConditions(conditions, options);
@@ -939,18 +2292,6 @@ var evaluateErrorRule = (errorRule, options) => {
     referenceRecord: { ...options.referenceRecord, ...referenceRecord }
   }));
 };
-init_esm_shims();
-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 }
-  });
-};
 var evaluateRules = (rules, options) => {
   for (const rule of rules) {
     if (rule.type === "endpoint") {
@@ -961,7 +2302,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;
       }
@@ -969,7 +2310,22 @@ var evaluateRules = (rules, options) => {
       throw new EndpointError(`Unknown endpoint rule: ${rule}`);
     }
   }
-  throw new EndpointError(`Rules evaluation failed`);
+  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
 };
 var resolveEndpoint = (ruleSetObject, options) => {
   const { endpointParams, logger } = options;
@@ -991,8 +2347,6 @@ var resolveEndpoint = (ruleSetObject, options) => {
   options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
   return endpoint;
 };
-init_esm_shims();
-init_esm_shims();
 var isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
   if (allowSubDomains) {
     for (const label of value.split(".")) {
@@ -1016,7 +2370,6 @@ var isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
   }
   return true;
 };
-init_esm_shims();
 var ARN_DELIMITER = ":";
 var RESOURCE_DELIMITER = "/";
 var parseArn = (value) => {
@@ -1035,7 +2388,6 @@ var parseArn = (value) => {
     resourceId
   };
 };
-init_esm_shims();
 var partitions_default = {
   partitions: [{
     id: "aws",
@@ -1055,6 +2407,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)"
       },
@@ -1085,11 +2440,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)"
@@ -1162,7 +2520,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)"
@@ -1172,41 +2530,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"
@@ -1219,35 +2571,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"
@@ -1257,16 +2612,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"
@@ -1276,19 +2631,25 @@ 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)"
       }
     }
   }],
@@ -1332,16 +2693,6 @@ var awsEndpointFunctions = {
   partition
 };
 customEndpointFunctions.aws = awsEndpointFunctions;
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var state = {
   warningEmitted: false
 };
@@ -1357,7 +2708,6 @@ updates please upgrade to a supported Node.js LTS version.
 More information can be found at: https://a.co/74kJMmI`);
   }
 };
-init_esm_shims();
 function setFeature2(context, feature, value) {
   if (!context.__aws_sdk_context) {
     context.__aws_sdk_context = {
@@ -1368,14 +2718,8 @@ function setFeature2(context, feature, value) {
   }
   context.__aws_sdk_context.features[feature] = value;
 }
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : void 0;
-init_esm_shims();
 var getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
-init_esm_shims();
-init_esm_shims();
 var isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 3e5;
 var getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
   const clockTimeInMs = Date.parse(clockTime);
@@ -1453,7 +2797,6 @@ var AwsSdkSigV4Signer = class {
     }
   }
 };
-init_esm_shims();
 var AwsSdkSigV4ASigner = class extends AwsSdkSigV4Signer {
   async sign(httpRequest, identity, signingProperties) {
     if (!HttpRequest.isInstance(httpRequest)) {
@@ -1470,10 +2813,7 @@ var AwsSdkSigV4ASigner = class extends AwsSdkSigV4Signer {
     return signedRequest;
   }
 };
-init_esm_shims();
-init_esm_shims();
 var getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : [];
-init_esm_shims();
 var getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`;
 var NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE";
 var NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference";
@@ -1495,7 +2835,6 @@ var NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = {
   },
   default: []
 };
-init_esm_shims();
 var resolveAwsSdkSigV4AConfig = (config) => {
   config.sigv4aSigningRegionSet = normalizeProvider2(config.sigv4aSigningRegionSet);
   return config;
@@ -1519,10 +2858,6 @@ var NODE_SIGV4A_CONFIG_OPTIONS = {
   },
   default: void 0
 };
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var ALGORITHM_QUERY_PARAM = "X-Amz-Algorithm";
 var CREDENTIAL_QUERY_PARAM = "X-Amz-Credential";
 var AMZ_DATE_QUERY_PARAM = "X-Amz-Date";
@@ -1562,7 +2897,6 @@ var UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
 var MAX_CACHE_SIZE = 50;
 var KEY_TYPE_IDENTIFIER = "aws4_request";
 var MAX_PRESIGNED_TTL = 60 * 60 * 24 * 7;
-init_esm_shims();
 var signingKeyCache = {};
 var cacheQueue = [];
 var createScope = (shortDate, region, service) => `${shortDate}/${region}/${service}/${KEY_TYPE_IDENTIFIER}`;
@@ -1587,7 +2921,6 @@ var hmac = (ctor, secret, data) => {
   hash.update(toUint8Array(data));
   return hash.digest();
 };
-init_esm_shims();
 var getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
   const canonical = {};
   for (const headerName of Object.keys(headers).sort()) {
@@ -1604,7 +2937,6 @@ var getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
   }
   return canonical;
 };
-init_esm_shims();
 var getPayloadHash = async ({ headers, body }, hashConstructor) => {
   for (const headerName of Object.keys(headers)) {
     if (headerName.toLowerCase() === SHA256_HEADER) {
@@ -1620,7 +2952,6 @@ var getPayloadHash = async ({ headers, body }, hashConstructor) => {
   }
   return UNSIGNED_PAYLOAD;
 };
-init_esm_shims();
 var HeaderFormatter = class {
   format(headers) {
     const chunks = [];
@@ -1703,6 +3034,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) {
@@ -1744,7 +3076,6 @@ function negate(bytes) {
       break;
   }
 }
-init_esm_shims();
 var hasHeader = (soughtHeader, headers) => {
   soughtHeader = soughtHeader.toLowerCase();
   for (const headerName of Object.keys(headers)) {
@@ -1754,7 +3085,6 @@ var hasHeader = (soughtHeader, headers) => {
   }
   return false;
 };
-init_esm_shims();
 var moveHeadersToQuery = (request, options = {}) => {
   const { headers, query = {} } = HttpRequest.clone(request);
   for (const name of Object.keys(headers)) {
@@ -1770,7 +3100,6 @@ var moveHeadersToQuery = (request, options = {}) => {
     query
   };
 };
-init_esm_shims();
 var prepareRequest = (request) => {
   request = HttpRequest.clone(request);
   for (const headerName of Object.keys(request.headers)) {
@@ -1780,8 +3109,6 @@ var prepareRequest = (request) => {
   }
   return request;
 };
-init_esm_shims();
-init_esm_shims();
 var getCanonicalQuery = ({ query = {} }) => {
   const keys = [];
   const serialized = {};
@@ -1800,21 +3127,26 @@ var getCanonicalQuery = ({ query = {} }) => {
   }
   return keys.sort().map((key) => serialized[key]).filter((serialized2) => serialized2).join("&");
 };
-init_esm_shims();
-var iso8601 = (time) => toDate(time).toISOString().replace(/\.\d{3}Z$/, "Z");
-var toDate = (time) => {
-  if (typeof time === "number") {
-    return new Date(time * 1e3);
-  }
-  if (typeof time === "string") {
-    if (Number(time)) {
-      return new Date(Number(time) * 1e3);
+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 time2 === "string") {
+    if (Number(time2)) {
+      return new Date(Number(time2) * 1e3);
     }
-    return new Date(time);
+    return new Date(time2);
   }
-  return time;
+  return time2;
 };
 var SignatureV4Base = class {
+  service;
+  regionProvider;
+  credentialProvider;
+  sha256;
+  uriEscapePath;
+  applyChecksum;
   constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
     this.service = service;
     this.sha256 = sha256;
@@ -1879,6 +3211,7 @@ ${toHex(hashedRequest)}`;
   }
 };
 var SignatureV4 = class extends SignatureV4Base {
+  headerFormatter = new HeaderFormatter();
   constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
     super({
       applyChecksum,
@@ -1888,7 +3221,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;
@@ -1995,10 +3327,6 @@ var SignatureV4 = class extends SignatureV4Base {
     return getSigningKey(this.sha256, credentials, shortDate, region, service || this.service);
   }
 };
-init_esm_shims();
-var signatureV4aContainer = {
-  SignatureV4a: null
-};
 var resolveAwsSdkSigV4Config = (config) => {
   let inputCredentials = config.credentials;
   let isUserSupplied = !!config.credentials;
@@ -2118,8 +3446,240 @@ function bindCallerConfig(config, credentialsProvider) {
   fn.configBound = true;
   return fn;
 }
-init_esm_shims();
-var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+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 {};
+  }
+};
+var warningEmitted = false;
+var emitWarningIfUnsupportedVersion2 = (version) => {
+  if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
+    warningEmitted = true;
+  }
+};
+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;
+};
+var getRetryConfiguration = (runtimeConfig) => {
+  return {
+    setRetryStrategy(retryStrategy) {
+      runtimeConfig.retryStrategy = retryStrategy;
+    },
+    retryStrategy() {
+      return runtimeConfig.retryStrategy;
+    }
+  };
+};
+var resolveRetryRuntimeConfig = (retryStrategyConfiguration) => {
+  const runtimeConfig = {};
+  runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy();
+  return runtimeConfig;
+};
+var getDefaultExtensionConfiguration = (runtimeConfig) => {
+  return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));
+};
+var resolveDefaultRuntimeConfig = (config) => {
+  return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config));
+};
+var NoOpLogger = class {
+  trace() {
+  }
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+};
+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;
+    }
+  }
+};
+var SerdeContextConfig = class {
+  serdeContext;
+  setSerdeContext(serdeContext) {
+    this.serdeContext = serdeContext;
+  }
+};
+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;
+  }
+}
 var ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
 async function checkFeatures(context, config, args) {
   const request = args.request;
@@ -2166,15 +3726,13 @@ async function checkFeatures(context, config, args) {
     }
   }
 }
-init_esm_shims();
 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 = "-";
-init_esm_shims();
 var BYTE_LIMIT = 1024;
 function encodeFeatures(features) {
   let buffer = "";
@@ -2206,7 +3764,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);
@@ -2259,10 +3817,18 @@ var getUserAgentPlugin = (config) => ({
     clientStack.add(userAgentMiddleware(config), getUserAgentMiddlewareOptions);
   }
 });
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
+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);
+  }
+};
 var isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));
 var getRealRegion = (region) => isFipsRegion(region) ? ["fips-aws-global", "aws-fips"].includes(region) ? "us-east-1" : region.replace(/fips-(dkr-|prod-)?|-fips/, "") : region;
 var resolveRegionConfig = (input) => {
@@ -2272,11 +3838,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();
@@ -2287,68 +3852,6 @@ var resolveRegionConfig = (input) => {
     }
   });
 };
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-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]}.`);
-};
-init_esm_shims();
-init_esm_shims();
-var SelectorType;
-(function(SelectorType2) {
-  SelectorType2["ENV"] = "env";
-  SelectorType2["CONFIG"] = "shared config entry";
-})(SelectorType || (SelectorType = {}));
-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
-};
-init_esm_shims();
-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
-};
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-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"
-};
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var CONTENT_LENGTH_HEADER = "content-length";
 function contentLengthMiddleware(bodyLengthChecker) {
   return (next) => async (args) => {
@@ -2383,11 +3886,6 @@ var getContentLengthPlugin = (options) => ({
     clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), contentLengthMiddlewareOptions);
   }
 });
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var resolveParamsForS3 = async (endpointParams) => {
   const bucket = endpointParams?.Bucket || "";
   if (typeof endpointParams.Bucket === "string") {
@@ -2419,7 +3917,6 @@ var isArnBucketName = (bucketName) => {
   }
   return isValidArn;
 };
-init_esm_shims();
 var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) => {
   const configProvider = async () => {
     const configValue = config[configKey] ?? config[canonicalEndpointParamKey];
@@ -2444,6 +3941,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) {
@@ -2459,8 +3959,6 @@ var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) =
   }
   return configProvider;
 };
-init_esm_shims();
-init_esm_shims();
 var ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
 var CONFIG_ENDPOINT_URL = "endpoint_url";
 var getEndpointUrlConfig = (serviceId) => ({
@@ -2492,7 +3990,6 @@ var getEndpointUrlConfig = (serviceId) => ({
   default: void 0
 });
 var getEndpointFromConfig = async (serviceId) => loadConfig(getEndpointUrlConfig(serviceId ?? ""))();
-init_esm_shims();
 var toEndpointV1 = (endpoint) => {
   if (typeof endpoint === "object") {
     if ("url" in endpoint) {
@@ -2503,7 +4000,7 @@ var toEndpointV1 = (endpoint) => {
   return parseUrl(endpoint);
 };
 var getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
-  if (!clientConfig.endpoint) {
+  if (!clientConfig.isCustomEndpoint) {
     let endpointFromConfig;
     if (clientConfig.serviceConfiguredEndpoint) {
       endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
@@ -2512,6 +4009,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);
@@ -2553,7 +4051,7 @@ var resolveParams = async (commandInput, instructionsSupplier, clientConfig) =>
 };
 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, {
@@ -2590,7 +4088,7 @@ var endpointMiddlewareOptions = {
   name: "endpointV2Middleware",
   override: true,
   relation: "before",
-  toMiddleware: serializerMiddlewareOption.name
+  toMiddleware: serializerMiddlewareOption2.name
 };
 var getEndpointPlugin = (config, instructions) => ({
   applyToStack: (clientStack) => {
@@ -2600,7 +4098,6 @@ var getEndpointPlugin = (config, instructions) => ({
     }), endpointMiddlewareOptions);
   }
 });
-init_esm_shims();
 var resolveEndpointConfig = (input) => {
   const tls = input.tls ?? true;
   const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input;
@@ -2622,13 +4119,6 @@ var resolveEndpointConfig = (input) => {
   };
   return resolvedConfig;
 };
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var RETRY_MODES;
 (function(RETRY_MODES2) {
   RETRY_MODES2["STANDARD"] = "standard";
@@ -2636,9 +4126,6 @@ var RETRY_MODES;
 })(RETRY_MODES || (RETRY_MODES = {}));
 var DEFAULT_MAX_ATTEMPTS = 3;
 var DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var THROTTLING_ERROR_CODES = [
   "BandwidthLimitExceeded",
   "EC2ThrottledException",
@@ -2658,6 +4145,8 @@ 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"];
+var isRetryableByTrait = (error) => error?.$retryable !== void 0;
 var isClockSkewCorrectedError = (error) => error.$metadata?.clockSkewCorrected;
 var isBrowserNetworkError = (error) => {
   const errorMessages = /* @__PURE__ */ new Set([
@@ -2674,7 +4163,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;
@@ -2686,14 +4175,24 @@ var isServerError = (error) => {
   return false;
 };
 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;
@@ -2782,9 +4281,6 @@ var DefaultRateLimiter = class _DefaultRateLimiter {
     return parseFloat(num.toFixed(8));
   }
 };
-DefaultRateLimiter.setTimeoutFn = setTimeout;
-init_esm_shims();
-init_esm_shims();
 var DEFAULT_RETRY_DELAY_BASE = 100;
 var MAXIMUM_RETRY_DELAY = 20 * 1e3;
 var THROTTLING_RETRY_DELAY_BASE = 500;
@@ -2794,7 +4290,6 @@ var TIMEOUT_RETRY_COST = 10;
 var NO_RETRY_INCREMENT = 1;
 var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
 var REQUEST_HEADER = "amz-sdk-request";
-init_esm_shims();
 var getDefaultRetryBackoffStrategy = () => {
   let delayBase = DEFAULT_RETRY_DELAY_BASE;
   const computeNextBackoffDelay = (attempts) => {
@@ -2808,7 +4303,6 @@ var getDefaultRetryBackoffStrategy = () => {
     setDelayBase
   };
 };
-init_esm_shims();
 var createDefaultRetryToken = ({ retryDelay, retryCount, retryCost }) => {
   const getRetryCount = () => retryCount;
   const getRetryDelay = () => Math.min(MAXIMUM_RETRY_DELAY, retryDelay);
@@ -2820,11 +4314,13 @@ var createDefaultRetryToken = ({ retryDelay, retryCount, retryCost }) => {
   };
 };
 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) {
@@ -2876,9 +4372,12 @@ var StandardRetryStrategy = class {
   }
 };
 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);
@@ -2896,8 +4395,6 @@ var AdaptiveRetryStrategy = class {
     this.standardRetryStrategy.recordSuccess(token);
   }
 };
-init_esm_shims();
-init_esm_shims();
 var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
 var CONFIG_MAX_ATTEMPTS = "max_attempts";
 var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
@@ -2947,52 +4444,7 @@ var NODE_RETRY_MODE_CONFIG_OPTIONS = {
   configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
   default: DEFAULT_RETRY_MODE
 };
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-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);
-}
-init_esm_shims();
-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]];
-}
-init_esm_shims();
-init_esm_shims();
-var native_default = {
-  randomUUID: crypto2.randomUUID
-};
-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;
-init_esm_shims();
 var isStreamingPayload = (request) => request?.body instanceof Readable || typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream;
-init_esm_shims();
 var asSdkError = (error) => {
   if (error instanceof Error)
     return error;
@@ -3014,7 +4466,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 {
@@ -3102,16 +4554,46 @@ var getRetryAfterHint = (response) => {
   const retryAfterDate = new Date(retryAfter);
   return retryAfterDate;
 };
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
+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]}.`);
+};
+var SelectorType;
+(function(SelectorType2) {
+  SelectorType2["ENV"] = "env";
+  SelectorType2["CONFIG"] = "shared config entry";
+})(SelectorType || (SelectorType = {}));
+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
+};
+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
+};
+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"
+};
 var crtAvailability = {
   isCrtAvailable: false
 };
@@ -3145,7 +4627,6 @@ var createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
     return resolvedUserAgent;
   };
 };
-init_esm_shims();
 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";
@@ -3154,9 +4635,10 @@ var NODE_APP_ID_CONFIG_OPTIONS = {
   configFileSelector: (profile) => profile[UA_APP_ID_INI_NAME] ?? profile[UA_APP_ID_INI_NAME_DEPRECATED],
   default: DEFAULT_UA_APP_ID
 };
-init_esm_shims();
-init_esm_shims();
 var Hash = class {
+  algorithmIdentifier;
+  secret;
+  hash;
   constructor(algorithmIdentifier, secret) {
     this.algorithmIdentifier = algorithmIdentifier;
     this.secret = secret;
@@ -3184,7 +4666,6 @@ function castSourceData(toCast, encoding) {
   }
   return fromArrayBuffer(toCast);
 }
-init_esm_shims();
 var calculateBodyLength = (body) => {
   if (!body) {
     return 0;
@@ -3197,23 +4678,21 @@ 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}`);
 };
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 var AWS_EXECUTION_ENV = "AWS_EXECUTION_ENV";
 var AWS_REGION_ENV = "AWS_REGION";
 var AWS_DEFAULT_REGION_ENV = "AWS_DEFAULT_REGION";
 var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
 var DEFAULTS_MODE_OPTIONS = ["in-region", "cross-region", "mobile", "standard", "legacy"];
 var IMDS_REGION_PATH = "/latest/meta-data/placement/region";
-init_esm_shims();
 var AWS_DEFAULTS_MODE_ENV = "AWS_DEFAULTS_MODE";
 var AWS_DEFAULTS_MODE_CONFIG = "defaults_mode";
 var NODE_DEFAULTS_MODE_CONFIG_OPTIONS = {
@@ -3263,15 +4742,13 @@ var inferPhysicalRegion = async () => {
   }
   if (!process.env[ENV_IMDS_DISABLED]) {
     try {
-      const { getInstanceMetadataEndpoint, httpRequest } = await import("./dist-es-SUPEA6VE-3B5JSW5C.js");
+      const { getInstanceMetadataEndpoint, httpRequest } = await import("./dist-es-BQW4ETQH-C7ZSD5EG.js");
       const endpoint = await getInstanceMetadataEndpoint();
       return (await httpRequest({ ...endpoint, path: IMDS_REGION_PATH })).toString();
     } catch (e) {
     }
   }
 };
-init_esm_shims();
-init_esm_shims();
 var getAwsRegionExtensionConfiguration = (runtimeConfig) => {
   return {
     setRegion(region) {
@@ -3287,23 +4764,37 @@ var resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) =
     region: awsRegionExtensionConfiguration.region()
   };
 };
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
-init_esm_shims();
 
 export {
+  Client,
+  deref,
+  getHttpHandlerExtensionConfiguration,
+  resolveHttpHandlerRuntimeConfig,
   getSmithyContext,
   normalizeProvider,
+  getSchemaSerdePlugin,
+  translateTraits,
+  NormalizedSchema,
+  TypeRegistry,
+  Command,
   getHttpAuthSchemeEndpointRuleSetPlugin,
-  getSerdePlugin,
   httpSigningMiddlewareOptions,
   getHttpSigningPlugin,
   createPaginator,
   DefaultIdentityProviderConfig,
+  toUint8Array,
+  collectBody,
+  extendedEncodeURIComponent,
+  v4,
+  LazyJsonString,
+  splitHeader,
+  NumericValue,
+  SerdeContext,
+  HttpProtocol,
+  determineTimestampFormat,
+  FromStringShapeDeserializer,
   NoAuthSigner,
+  ServiceException,
   resolveHostHeaderConfig,
   getHostHeaderPlugin,
   getLoggerPlugin,
@@ -3321,17 +4812,18 @@ export {
   resolveAwsSdkSigV4AConfig,
   NODE_SIGV4A_CONFIG_OPTIONS,
   SignatureV4,
-  signatureV4aContainer,
   resolveAwsSdkSigV4Config,
-  collectBodyString,
+  loadConfigsForDefaultMode,
+  emitWarningIfUnsupportedVersion2,
+  getDefaultExtensionConfiguration,
+  resolveDefaultRuntimeConfig,
+  NoOpLogger,
+  ProtocolLib,
+  SerdeContextConfig,
+  serializingStructIterator,
+  deserializingStructIterator,
   getUserAgentPlugin,
   resolveRegionConfig,
-  booleanSelector,
-  SelectorType,
-  NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS,
-  NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS,
-  NODE_REGION_CONFIG_OPTIONS,
-  NODE_REGION_CONFIG_FILE_OPTIONS,
   getContentLengthPlugin,
   resolveParams,
   getEndpointPlugin,
@@ -3341,6 +4833,12 @@ export {
   resolveRetryConfig,
   NODE_RETRY_MODE_CONFIG_OPTIONS,
   getRetryPlugin,
+  booleanSelector,
+  SelectorType,
+  NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS,
+  NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS,
+  NODE_REGION_CONFIG_OPTIONS,
+  NODE_REGION_CONFIG_FILE_OPTIONS,
   createDefaultUserAgentProvider,
   NODE_APP_ID_CONFIG_OPTIONS,
   Hash,