@etainabl/nodejs-sdk 1.3.167 → 1.3.174

package/dist/esm/{chunk-COGWOFTA.js → chunk-HR3W7R4B.js}

@@ -1,11 +1,8 @@
-import {
-  SCHEMA
-} from "./chunk-5UJEKK4C.js";
 import {
   loadConfig,
   memoize,
   parseUrl
-} from "./chunk-IMDTX6W5.js";
+} from "./chunk-3G3VXGQN.js";
 import {
   HttpRequest,
   HttpResponse,
@@ -13,24 +10,24 @@ import {
   fromBase64,
   fromHex,
   toBase64,
-  toHex,
-  toUtf8
-} from "./chunk-JI6PVVK3.js";
+  toHex
+} from "./chunk-D74LA2XQ.js";
 import {
   fromArrayBuffer,
   fromString,
   fromUtf8,
-  isArrayBuffer
-} from "./chunk-KH6HADHN.js";
+  isArrayBuffer,
+  toUtf8
+} from "./chunk-Z63CAAFL.js";
 import {
   CONFIG_PREFIX_SEPARATOR
-} from "./chunk-ZW5YT27C.js";
+} from "./chunk-CRX53WMM.js";
 import {
   setCredentialFeature
 } from "./chunk-UZGMBQZB.js";
 import {
   ProviderError
-} from "./chunk-R2ZTENKB.js";
+} from "./chunk-IX2LY325.js";
 
 // node_modules/@smithy/middleware-stack/dist-es/MiddlewareStack.js
 var getAllAliases = (name, aliases) => {
@@ -299,9 +296,12 @@ var priorityWeights = {
 
 // node_modules/@smithy/smithy-client/dist-es/client.js
 var Client = class {
+  config;
+  middlewareStack = constructStack();
+  initConfig;
+  handlers;
   constructor(config) {
     this.config = config;
-    this.middlewareStack = constructStack();
   }
   send(command, optionsOrCb, cb) {
     const options = typeof optionsOrCb !== "function" ? optionsOrCb : void 0;
@@ -398,111 +398,50 @@ var normalizeProvider = (input) => {
   return () => promisified;
 };
 
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js
-var Schema = class {
-  constructor(name, traits) {
-    this.name = name;
-    this.traits = traits;
-  }
-};
-
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/ListSchema.js
-var ListSchema = class _ListSchema extends Schema {
-  constructor(name, traits, valueSchema) {
-    super(name, traits);
-    this.name = name;
-    this.traits = traits;
-    this.valueSchema = valueSchema;
-    this.symbol = _ListSchema.symbol;
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _ListSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const list = lhs;
-      return list.symbol === _ListSchema.symbol;
-    }
-    return isPrototype;
-  }
-};
-ListSchema.symbol = Symbol.for("@smithy/core/schema::ListSchema");
-
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/MapSchema.js
-var MapSchema = class _MapSchema extends Schema {
-  constructor(name, traits, keySchema, valueSchema) {
-    super(name, traits);
-    this.name = name;
-    this.traits = traits;
-    this.keySchema = keySchema;
-    this.valueSchema = valueSchema;
-    this.symbol = _MapSchema.symbol;
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _MapSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const map = lhs;
-      return map.symbol === _MapSchema.symbol;
-    }
-    return isPrototype;
-  }
-};
-MapSchema.symbol = Symbol.for("@smithy/core/schema::MapSchema");
-
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js
-var StructureSchema = class _StructureSchema extends Schema {
-  constructor(name, traits, memberNames, memberList) {
-    super(name, traits);
-    this.name = name;
-    this.traits = traits;
-    this.memberNames = memberNames;
-    this.memberList = memberList;
-    this.symbol = _StructureSchema.symbol;
-    this.members = {};
-    for (let i = 0; i < memberNames.length; ++i) {
-      this.members[memberNames[i]] = Array.isArray(memberList[i]) ? memberList[i] : [memberList[i], 0];
-    }
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _StructureSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const struct = lhs;
-      return struct.symbol === _StructureSchema.symbol;
-    }
-    return isPrototype;
-  }
-};
-StructureSchema.symbol = Symbol.for("@smithy/core/schema::StructureSchema");
-
-// node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js
-var SimpleSchema = class _SimpleSchema extends Schema {
-  constructor(name, schemaRef, traits) {
-    super(name, traits);
-    this.name = name;
-    this.schemaRef = schemaRef;
-    this.traits = traits;
-    this.symbol = _SimpleSchema.symbol;
-  }
-  static [Symbol.hasInstance](lhs) {
-    const isPrototype = _SimpleSchema.prototype.isPrototypeOf(lhs);
-    if (!isPrototype && typeof lhs === "object" && lhs !== null) {
-      const sim = lhs;
-      return sim.symbol === _SimpleSchema.symbol;
-    }
-    return isPrototype;
-  }
-};
-SimpleSchema.symbol = Symbol.for("@smithy/core/schema::SimpleSchema");
+// node_modules/@smithy/core/dist-es/submodules/schema/schemas/translateTraits.js
+function translateTraits(indicator) {
+  if (typeof indicator === "object") {
+    return indicator;
+  }
+  indicator = indicator | 0;
+  const traits = {};
+  let i = 0;
+  for (const trait of [
+    "httpLabel",
+    "idempotent",
+    "idempotencyToken",
+    "sensitive",
+    "httpPayload",
+    "httpResponseCode",
+    "httpQueryParams"
+  ]) {
+    if ((indicator >> i++ & 1) === 1) {
+      traits[trait] = 1;
+    }
+  }
+  return traits;
+}
 
 // node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js
 var NormalizedSchema = class _NormalizedSchema {
+  ref;
+  memberName;
+  static symbol = Symbol.for("@smithy/nor");
+  symbol = _NormalizedSchema.symbol;
+  name;
+  schema;
+  _isMemberSchema;
+  traits;
+  memberTraits;
+  normalizedTraits;
   constructor(ref, memberName) {
     this.ref = ref;
     this.memberName = memberName;
-    this.symbol = _NormalizedSchema.symbol;
     const traitStack = [];
     let _ref = ref;
     let schema = ref;
     this._isMemberSchema = false;
-    while (Array.isArray(_ref)) {
+    while (isMemberSchema(_ref)) {
       traitStack.push(_ref[1]);
       _ref = _ref[0];
       schema = deref(_ref);
@@ -512,261 +451,173 @@ var NormalizedSchema = class _NormalizedSchema {
       this.memberTraits = {};
       for (let i = traitStack.length - 1; i >= 0; --i) {
         const traitSet = traitStack[i];
-        Object.assign(this.memberTraits, _NormalizedSchema.translateTraits(traitSet));
+        Object.assign(this.memberTraits, translateTraits(traitSet));
       }
     } else {
       this.memberTraits = 0;
     }
     if (schema instanceof _NormalizedSchema) {
-      this.name = schema.name;
-      this.traits = schema.traits;
-      this._isMemberSchema = schema._isMemberSchema;
-      this.schema = schema.schema;
-      this.memberTraits = Object.assign({}, schema.getMemberTraits(), this.getMemberTraits());
+      const computedMemberTraits = this.memberTraits;
+      Object.assign(this, schema);
+      this.memberTraits = Object.assign({}, computedMemberTraits, schema.getMemberTraits(), this.getMemberTraits());
       this.normalizedTraits = void 0;
-      this.ref = schema.ref;
       this.memberName = memberName ?? schema.memberName;
       return;
     }
     this.schema = deref(schema);
-    if (this.schema && typeof this.schema === "object") {
-      this.traits = this.schema?.traits ?? {};
+    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;
     }
-    this.name = (typeof this.schema === "object" ? this.schema?.name : void 0) ?? this.memberName ?? this.getSchemaName();
     if (this._isMemberSchema && !memberName) {
-      throw new Error(`@smithy/core/schema - NormalizedSchema member schema ${this.getName(true)} must initialize with memberName argument.`);
+      throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
     }
   }
   static [Symbol.hasInstance](lhs) {
-    const isPrototype = _NormalizedSchema.prototype.isPrototypeOf(lhs);
+    const isPrototype = this.prototype.isPrototypeOf(lhs);
     if (!isPrototype && typeof lhs === "object" && lhs !== null) {
       const ns = lhs;
-      return ns.symbol === _NormalizedSchema.symbol;
+      return ns.symbol === this.symbol;
     }
     return isPrototype;
   }
-  static of(ref, memberName) {
-    if (ref instanceof _NormalizedSchema) {
-      return ref;
-    }
-    return new _NormalizedSchema(ref, memberName);
-  }
-  static translateTraits(indicator) {
-    if (typeof indicator === "object") {
-      return indicator;
-    }
-    indicator = indicator | 0;
-    const traits = {};
-    if ((indicator & 1) === 1) {
-      traits.httpLabel = 1;
+  static of(ref) {
+    const sc = deref(ref);
+    if (sc instanceof _NormalizedSchema) {
+      return sc;
     }
-    if ((indicator >> 1 & 1) === 1) {
-      traits.idempotent = 1;
-    }
-    if ((indicator >> 2 & 1) === 1) {
-      traits.idempotencyToken = 1;
-    }
-    if ((indicator >> 3 & 1) === 1) {
-      traits.sensitive = 1;
-    }
-    if ((indicator >> 4 & 1) === 1) {
-      traits.httpPayload = 1;
-    }
-    if ((indicator >> 5 & 1) === 1) {
-      traits.httpResponseCode = 1;
-    }
-    if ((indicator >> 6 & 1) === 1) {
-      traits.httpQueryParams = 1;
-    }
-    return traits;
-  }
-  static memberFrom(memberSchema, memberName) {
-    if (memberSchema instanceof _NormalizedSchema) {
-      memberSchema.memberName = memberName;
-      memberSchema._isMemberSchema = true;
-      return memberSchema;
+    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(memberSchema, memberName);
+    return new _NormalizedSchema(sc);
   }
   getSchema() {
-    if (this.schema instanceof _NormalizedSchema) {
-      return this.schema = this.schema.getSchema();
-    }
-    if (this.schema instanceof SimpleSchema) {
-      return deref(this.schema.schemaRef);
+    const sc = this.schema;
+    if (sc[0] === 0) {
+      return sc[4];
     }
-    return deref(this.schema);
+    return sc;
   }
   getName(withNamespace = false) {
-    if (!withNamespace) {
-      if (this.name && this.name.includes("#")) {
-        return this.name.split("#")[1];
-      }
-    }
-    return this.name || void 0;
+    const { name } = this;
+    const short = !withNamespace && name && name.includes("#");
+    return short ? name.split("#")[1] : name || void 0;
   }
   getMemberName() {
-    if (!this.isMemberSchema()) {
-      throw new Error(`@smithy/core/schema - cannot get member name on non-member schema: ${this.getName(true)}`);
-    }
     return this.memberName;
   }
   isMemberSchema() {
     return this._isMemberSchema;
   }
-  isUnitSchema() {
-    return this.getSchema() === "unit";
-  }
   isListSchema() {
-    const inner = this.getSchema();
-    if (typeof inner === "number") {
-      return inner >= SCHEMA.LIST_MODIFIER && inner < SCHEMA.MAP_MODIFIER;
-    }
-    return inner instanceof ListSchema;
+    const sc = this.getSchema();
+    return typeof sc === "number" ? sc >= 64 && sc < 128 : sc[0] === 1;
   }
   isMapSchema() {
-    const inner = this.getSchema();
-    if (typeof inner === "number") {
-      return inner >= SCHEMA.MAP_MODIFIER && inner <= 255;
-    }
-    return inner instanceof MapSchema;
-  }
-  isDocumentSchema() {
-    return this.getSchema() === SCHEMA.DOCUMENT;
+    const sc = this.getSchema();
+    return typeof sc === "number" ? sc >= 128 && sc <= 255 : sc[0] === 2;
   }
   isStructSchema() {
-    const inner = this.getSchema();
-    return inner !== null && typeof inner === "object" && "members" in inner || inner instanceof StructureSchema;
+    const sc = this.getSchema();
+    return sc[0] === 3 || sc[0] === -3;
   }
   isBlobSchema() {
-    return this.getSchema() === SCHEMA.BLOB || this.getSchema() === SCHEMA.STREAMING_BLOB;
+    const sc = this.getSchema();
+    return sc === 21 || sc === 42;
   }
   isTimestampSchema() {
-    const schema = this.getSchema();
-    return typeof schema === "number" && schema >= SCHEMA.TIMESTAMP_DEFAULT && schema <= SCHEMA.TIMESTAMP_EPOCH_SECONDS;
+    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() === SCHEMA.STRING;
+    return this.getSchema() === 0;
   }
   isBooleanSchema() {
-    return this.getSchema() === SCHEMA.BOOLEAN;
+    return this.getSchema() === 2;
   }
   isNumericSchema() {
-    return this.getSchema() === SCHEMA.NUMERIC;
+    return this.getSchema() === 1;
   }
   isBigIntegerSchema() {
-    return this.getSchema() === SCHEMA.BIG_INTEGER;
+    return this.getSchema() === 17;
   }
   isBigDecimalSchema() {
-    return this.getSchema() === SCHEMA.BIG_DECIMAL;
+    return this.getSchema() === 19;
   }
   isStreaming() {
-    const streaming = !!this.getMergedTraits().streaming;
-    if (streaming) {
-      return true;
-    }
-    return this.getSchema() === SCHEMA.STREAMING_BLOB;
+    const { streaming } = this.getMergedTraits();
+    return !!streaming || this.getSchema() === 42;
   }
   isIdempotencyToken() {
-    if (typeof this.traits === "number") {
-      return (this.traits & 4) === 4;
-    } else if (typeof this.traits === "object") {
-      return !!this.traits.idempotencyToken;
-    }
-    return false;
+    const match = (traits2) => (traits2 & 4) === 4 || !!traits2?.idempotencyToken;
+    const { normalizedTraits, traits, memberTraits } = this;
+    return match(normalizedTraits) || match(traits) || match(memberTraits);
   }
   getMergedTraits() {
-    if (this.normalizedTraits) {
-      return this.normalizedTraits;
-    }
-    this.normalizedTraits = {
+    return this.normalizedTraits ?? (this.normalizedTraits = {
       ...this.getOwnTraits(),
       ...this.getMemberTraits()
-    };
-    return this.normalizedTraits;
+    });
   }
   getMemberTraits() {
-    return _NormalizedSchema.translateTraits(this.memberTraits);
+    return translateTraits(this.memberTraits);
   }
   getOwnTraits() {
-    return _NormalizedSchema.translateTraits(this.traits);
+    return translateTraits(this.traits);
   }
   getKeySchema() {
-    if (this.isDocumentSchema()) {
-      return _NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "key");
-    }
-    if (!this.isMapSchema()) {
-      throw new Error(`@smithy/core/schema - cannot get key schema for non-map schema: ${this.getName(true)}`);
+    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();
-    if (typeof schema === "number") {
-      return _NormalizedSchema.memberFrom([63 & schema, 0], "key");
-    }
-    return _NormalizedSchema.memberFrom([schema.keySchema, 0], "key");
+    const memberSchema = isDoc ? 15 : schema[4] ?? 0;
+    return member([memberSchema, 0], "key");
   }
   getValueSchema() {
-    const schema = this.getSchema();
-    if (typeof schema === "number") {
-      if (this.isMapSchema()) {
-        return _NormalizedSchema.memberFrom([63 & schema, 0], "value");
-      } else if (this.isListSchema()) {
-        return _NormalizedSchema.memberFrom([63 & schema, 0], "member");
-      }
-    }
-    if (schema && typeof schema === "object") {
-      if (this.isStructSchema()) {
-        throw new Error(`cannot call getValueSchema() with StructureSchema ${this.getName(true)}`);
-      }
-      const collection = schema;
-      if ("valueSchema" in collection) {
-        if (this.isMapSchema()) {
-          return _NormalizedSchema.memberFrom([collection.valueSchema, 0], "value");
-        } else if (this.isListSchema()) {
-          return _NormalizedSchema.memberFrom([collection.valueSchema, 0], "member");
-        }
-      }
+    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");
     }
-    if (this.isDocumentSchema()) {
-      return _NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], "value");
-    }
-    throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a value member.`);
-  }
-  hasMemberSchema(member) {
-    if (this.isStructSchema()) {
-      const struct = this.getSchema();
-      return member in struct.members;
-    }
-    return false;
+    throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`);
   }
-  getMemberSchema(member) {
-    if (this.isStructSchema()) {
-      const struct = this.getSchema();
-      if (!(member in struct.members)) {
-        throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have a member with name=${member}.`);
-      }
-      return _NormalizedSchema.memberFrom(struct.members[member], 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 _NormalizedSchema.memberFrom([SCHEMA.DOCUMENT, 0], member);
+      return member([15, 0], memberName);
     }
-    throw new Error(`@smithy/core/schema - the schema ${this.getName(true)} does not have members.`);
+    throw new Error(`@smithy/core/schema - ${this.getName(true)} has no no member=${memberName}.`);
   }
   getMemberSchemas() {
-    const { schema } = this;
-    const struct = schema;
-    if (!struct || typeof struct !== "object") {
-      return {};
-    }
-    if ("members" in struct) {
-      const buffer = {};
-      for (const member of struct.memberNames) {
-        buffer[member] = this.getMemberSchema(member);
+    const buffer = {};
+    try {
+      for (const [k, v] of this.structIterator()) {
+        buffer[k] = v;
       }
-      return buffer;
+    } catch (ignored) {
     }
-    return {};
+    return buffer;
   }
   getEventStreamMember() {
     if (this.isStructSchema()) {
@@ -783,34 +634,26 @@ var NormalizedSchema = class _NormalizedSchema {
       return;
     }
     if (!this.isStructSchema()) {
-      throw new Error("@smithy/core/schema - cannot acquire structIterator on non-struct schema.");
+      throw new Error("@smithy/core/schema - cannot iterate non-struct schema.");
     }
     const struct = this.getSchema();
-    for (let i = 0; i < struct.memberNames.length; ++i) {
-      yield [struct.memberNames[i], _NormalizedSchema.memberFrom([struct.memberList[i], 0], struct.memberNames[i])];
-    }
-  }
-  getSchemaName() {
-    const schema = this.getSchema();
-    if (typeof schema === "number") {
-      const _schema = 63 & schema;
-      const container = 192 & schema;
-      const type = Object.entries(SCHEMA).find(([, value]) => {
-        return value === _schema;
-      })?.[0] ?? "Unknown";
-      switch (container) {
-        case SCHEMA.MAP_MODIFIER:
-          return `${type}Map`;
-        case SCHEMA.LIST_MODIFIER:
-          return `${type}List`;
-        case 0:
-          return type;
-      }
+    for (let i = 0; i < struct[4].length; ++i) {
+      yield [struct[4][i], member([struct[5][i], 0], struct[4][i])];
     }
-    return "Unknown";
   }
 };
-NormalizedSchema.symbol = Symbol.for("@smithy/core/schema::NormalizedSchema");
+function member(memberSchema, memberName) {
+  if (memberSchema instanceof NormalizedSchema) {
+    return Object.assign(memberSchema, {
+      memberName,
+      _isMemberSchema: true
+    });
+  }
+  const internalCtorAccess = NormalizedSchema;
+  return new internalCtorAccess(memberSchema, memberName);
+}
+var isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
+var isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;
 
 // node_modules/@smithy/smithy-client/dist-es/schemaLogFilter.js
 var SENSITIVE_STRING = "***SensitiveInformation***";
@@ -835,9 +678,9 @@ function schemaLogFilter(schema, data) {
   } else if (ns.isStructSchema() && typeof data === "object") {
     const object = data;
     const newObject = {};
-    for (const [member, memberNs] of ns.structIterator()) {
-      if (object[member] != null) {
-        newObject[member] = schemaLogFilter(memberNs, object[member]);
+    for (const [member2, memberNs] of ns.structIterator()) {
+      if (object[member2] != null) {
+        newObject[member2] = schemaLogFilter(memberNs, object[member2]);
       }
     }
     return newObject;
@@ -847,9 +690,8 @@ function schemaLogFilter(schema, data) {
 
 // node_modules/@smithy/smithy-client/dist-es/command.js
 var Command = class {
-  constructor() {
-    this.middlewareStack = constructStack();
-  }
+  middlewareStack = constructStack();
+  schema;
   static classBuilder() {
     return new ClassBuilder();
   }
@@ -876,20 +718,19 @@ var Command = class {
   }
 };
 var ClassBuilder = class {
-  constructor() {
-    this._init = () => {
-    };
-    this._ep = {};
-    this._middlewareFn = () => [];
-    this._commandName = "";
-    this._clientName = "";
-    this._additionalContext = {};
-    this._smithyContext = {};
-    this._inputFilterSensitiveLog = void 0;
-    this._outputFilterSensitiveLog = void 0;
-    this._serializer = null;
-    this._deserializer = null;
-  }
+  _init = () => {
+  };
+  _ep = {};
+  _middlewareFn = () => [];
+  _commandName = "";
+  _clientName = "";
+  _additionalContext = {};
+  _smithyContext = {};
+  _inputFilterSensitiveLog = void 0;
+  _outputFilterSensitiveLog = void 0;
+  _serializer = null;
+  _deserializer = null;
+  _operationSchema;
   init(cb) {
     this._init = cb;
   }
@@ -940,29 +781,33 @@ var ClassBuilder = class {
     const closure = this;
     let CommandRef;
     return CommandRef = class extends Command {
+      input;
       static getEndpointParameterInstructions() {
         return closure._ep;
       }
       constructor(...[input]) {
         super();
-        this.serialize = closure._serializer;
-        this.deserialize = closure._deserializer;
         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 ?? (closure._operationSchema ? schemaLogFilter.bind(null, closure._operationSchema.input) : (_) => _),
-          outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (closure._operationSchema ? schemaLogFilter.bind(null, closure._operationSchema.output) : (_) => _),
+          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;
     };
   }
 };
@@ -1080,6 +925,56 @@ var getRecursionDetectionPlugin = (options) => ({
   }
 });
 
+// node_modules/@smithy/smithy-client/dist-es/constants.js
+var SENSITIVE_STRING2 = "***SensitiveInformation***";
+
+// node_modules/@smithy/smithy-client/dist-es/exceptions.js
+var ServiceException = class _ServiceException extends Error {
+  $fault;
+  $response;
+  $retryable;
+  $metadata;
+  constructor(options) {
+    super(options.message);
+    Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
+    this.name = options.name;
+    this.$fault = options.$fault;
+    this.$metadata = options.$metadata;
+  }
+  static isInstance(value) {
+    if (!value)
+      return false;
+    const candidate = value;
+    return _ServiceException.prototype.isPrototypeOf(candidate) || Boolean(candidate.$fault) && Boolean(candidate.$metadata) && (candidate.$fault === "client" || candidate.$fault === "server");
+  }
+  static [Symbol.hasInstance](instance) {
+    if (!instance)
+      return false;
+    const candidate = instance;
+    if (this === _ServiceException) {
+      return _ServiceException.isInstance(instance);
+    }
+    if (_ServiceException.isInstance(instance)) {
+      if (candidate.name && this.name) {
+        return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
+      }
+      return this.prototype.isPrototypeOf(instance);
+    }
+    return false;
+  }
+};
+var decorateServiceException = (exception, additions = {}) => {
+  Object.entries(additions).filter(([, v]) => v !== void 0).forEach(([k, v]) => {
+    if (exception[k] == void 0 || exception[k] === "") {
+      exception[k] = v;
+    }
+  });
+  const message = exception.message || exception.Message || "UnknownError";
+  exception.message = message;
+  delete exception.Message;
+  return exception;
+};
+
 // node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/resolveAuthOptions.js
 var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
   if (!authSchemePreference || authSchemePreference.length === 0) {
@@ -1173,7 +1068,10 @@ var deserializerMiddleware = (options, deserializer) => (next, context) => async
     };
   } 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.`;
@@ -1292,8 +1190,8 @@ var getHttpSigningPlugin = (config) => ({
 
 // node_modules/@smithy/core/dist-es/util-identity-and-auth/DefaultIdentityProviderConfig.js
 var DefaultIdentityProviderConfig = class {
+  authSchemes = /* @__PURE__ */ new Map();
   constructor(config) {
-    this.authSchemes = /* @__PURE__ */ new Map();
     for (const [key, value] of Object.entries(config)) {
       if (value !== void 0) {
         this.authSchemes.set(key, value);
@@ -1324,36 +1222,26 @@ var toUint8Array = (data) => {
   return new Uint8Array(data);
 };
 
-// node_modules/@smithy/util-stream/dist-es/blob/transforms.js
-function transformToString(payload, encoding = "utf-8") {
-  if (encoding === "base64") {
-    return toBase64(payload);
-  }
-  return toUtf8(payload);
-}
-function transformFromString(str, encoding) {
-  if (encoding === "base64") {
-    return Uint8ArrayBlobAdapter.mutate(fromBase64(str));
-  }
-  return Uint8ArrayBlobAdapter.mutate(fromUtf8(str));
-}
-
 // node_modules/@smithy/util-stream/dist-es/blob/Uint8ArrayBlobAdapter.js
 var Uint8ArrayBlobAdapter = class _Uint8ArrayBlobAdapter extends Uint8Array {
   static fromString(source, encoding = "utf-8") {
-    switch (typeof source) {
-      case "string":
-        return transformFromString(source, encoding);
-      default:
-        throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+    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") {
-    return transformToString(this, encoding);
+    if (encoding === "base64") {
+      return toBase64(this);
+    }
+    return toUtf8(this);
   }
 };
 
@@ -1376,52 +1264,22 @@ function extendedEncodeURIComponent(str) {
   });
 }
 
-// node_modules/uuid/dist/esm-node/rng.js
-import crypto from "crypto";
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    crypto.randomFillSync(rnds8Pool);
-    poolPtr = 0;
-  }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// node_modules/uuid/dist/esm-node/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
-}
-
-// node_modules/uuid/dist/esm-node/native.js
+// node_modules/@smithy/uuid/dist-es/randomUUID.js
 import crypto2 from "crypto";
-var native_default = {
-  randomUUID: crypto2.randomUUID
-};
+var randomUUID = crypto2.randomUUID.bind(crypto2);
 
-// node_modules/uuid/dist/esm-node/v4.js
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
+// node_modules/@smithy/uuid/dist-es/v4.js
+var decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+var v4 = () => {
+  if (randomUUID) {
+    return randomUUID();
   }
-  options = options || {};
-  const rnds = options.random || (options.rng || rng)();
+  const rnds = new Uint8Array(16);
+  crypto.getRandomValues(rnds);
   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;
+  return decimalToHex[rnds[0]] + decimalToHex[rnds[1]] + decimalToHex[rnds[2]] + decimalToHex[rnds[3]] + "-" + decimalToHex[rnds[4]] + decimalToHex[rnds[5]] + "-" + decimalToHex[rnds[6]] + decimalToHex[rnds[7]] + "-" + decimalToHex[rnds[8]] + decimalToHex[rnds[9]] + "-" + decimalToHex[rnds[10]] + decimalToHex[rnds[11]] + decimalToHex[rnds[12]] + decimalToHex[rnds[13]] + decimalToHex[rnds[14]] + decimalToHex[rnds[15]];
+};
 
 // node_modules/@smithy/core/dist-es/setFeature.js
 function setFeature(context, feature, value) {
@@ -1436,7 +1294,9 @@ function setFeature(context, feature, value) {
 }
 
 // node_modules/@smithy/core/dist-es/util-identity-and-auth/memoizeIdentityProvider.js
-var createIsIdentityExpiredFunction = (expirationMs) => (identity) => doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
+var 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;
@@ -1517,57 +1377,12 @@ function resolveUserAgentConfig(input) {
   });
 }
 
-// node_modules/@smithy/smithy-client/dist-es/constants.js
-var SENSITIVE_STRING2 = "***SensitiveInformation***";
-
-// node_modules/@smithy/smithy-client/dist-es/exceptions.js
-var ServiceException = class _ServiceException extends Error {
-  constructor(options) {
-    super(options.message);
-    Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
-    this.name = options.name;
-    this.$fault = options.$fault;
-    this.$metadata = options.$metadata;
-  }
-  static isInstance(value) {
-    if (!value)
-      return false;
-    const candidate = value;
-    return _ServiceException.prototype.isPrototypeOf(candidate) || Boolean(candidate.$fault) && Boolean(candidate.$metadata) && (candidate.$fault === "client" || candidate.$fault === "server");
-  }
-  static [Symbol.hasInstance](instance) {
-    if (!instance)
-      return false;
-    const candidate = instance;
-    if (this === _ServiceException) {
-      return _ServiceException.isInstance(instance);
-    }
-    if (_ServiceException.isInstance(instance)) {
-      if (candidate.name && this.name) {
-        return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
-      }
-      return this.prototype.isPrototypeOf(instance);
-    }
-    return false;
-  }
-};
-var decorateServiceException = (exception, additions = {}) => {
-  Object.entries(additions).filter(([, v]) => v !== void 0).forEach(([k, v]) => {
-    if (exception[k] == void 0 || exception[k] === "") {
-      exception[k] = v;
-    }
-  });
-  const message = exception.message || exception.Message || "UnknownError";
-  exception.message = message;
-  delete exception.Message;
-  return exception;
-};
-
 // node_modules/@smithy/util-endpoints/dist-es/cache/EndpointCache.js
 var EndpointCache = class {
+  capacity;
+  data = /* @__PURE__ */ new Map();
+  parameters = [];
   constructor({ size, params }) {
-    this.data = /* @__PURE__ */ new Map();
-    this.parameters = [];
     this.capacity = size ?? 50;
     if (params) {
       this.parameters = params;
@@ -1832,22 +1647,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.`);
 };
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/callFunction.js
 var callFunction = ({ fn, argv }, options) => {
-  const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : evaluateExpression(arg, "arg", options));
+  const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : group.evaluateExpression(arg, "arg", options));
   const fnSegments = fn.split(".");
   if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {
     return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);
   }
   return endpointFunctions[fn](...evaluatedArgs);
 };
+var group = {
+  evaluateExpression,
+  callFunction
+};
 
 // node_modules/@smithy/util-endpoints/dist-es/utils/evaluateCondition.js
 var evaluateCondition = ({ assign, ...fnArgs }, options) => {
@@ -1896,7 +1713,11 @@ var getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((a
   })
 }), {});
 
-// node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperty.js
+// node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js
+var getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
+  ...acc,
+  [propertyKey]: group2.getEndpointProperty(propertyVal, options)
+}), {});
 var getEndpointProperty = (property, options) => {
   if (Array.isArray(property)) {
     return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
@@ -1908,19 +1729,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}`);
   }
 };
-
-// node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js
-var getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
-  ...acc,
-  [propertyKey]: getEndpointProperty(propertyVal, options)
-}), {});
+var group2 = {
+  getEndpointProperty,
+  getEndpointProperties
+};
 
 // node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointUrl.js
 var getEndpointUrl = (endpointUrl, options) => {
@@ -1973,19 +1792,6 @@ var evaluateErrorRule = (errorRule, options) => {
   }));
 };
 
-// node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTreeRule.js
-var evaluateTreeRule = (treeRule, options) => {
-  const { conditions, rules } = treeRule;
-  const { result, referenceRecord } = evaluateConditions(conditions, options);
-  if (!result) {
-    return;
-  }
-  return evaluateRules(rules, {
-    ...options,
-    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
-  });
-};
-
 // node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js
 var evaluateRules = (rules, options) => {
   for (const rule of rules) {
@@ -1997,7 +1803,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;
       }
@@ -2007,6 +1813,21 @@ var evaluateRules = (rules, options) => {
   }
   throw new EndpointError(`Rules evaluation failed`);
 };
+var evaluateTreeRule = (treeRule, options) => {
+  const { conditions, rules } = treeRule;
+  const { result, referenceRecord } = evaluateConditions(conditions, options);
+  if (!result) {
+    return;
+  }
+  return group3.evaluateRules(rules, {
+    ...options,
+    referenceRecord: { ...options.referenceRecord, ...referenceRecord }
+  });
+};
+var group3 = {
+  evaluateRules,
+  evaluateTreeRule
+};
 
 // node_modules/@smithy/util-endpoints/dist-es/resolveEndpoint.js
 var resolveEndpoint = (ruleSetObject, options) => {
@@ -2128,14 +1949,11 @@ 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 global region"
+        description: "AWS Standard global region"
       },
       "ca-central-1": {
         description: "Canada (Central)"
@@ -2208,7 +2026,7 @@ var partitions_default = {
     regionRegex: "^cn\\-\\w+\\-\\d+$",
     regions: {
       "aws-cn-global": {
-        description: "aws-cn global region"
+        description: "AWS China global region"
       },
       "cn-north-1": {
         description: "China (Beijing)"
@@ -2218,26 +2036,32 @@ var partitions_default = {
       }
     }
   }, {
-    id: "aws-eusc",
+    id: "aws-us-gov",
     outputs: {
-      dnsSuffix: "amazonaws.eu",
-      dualStackDnsSuffix: "api.amazonwebservices.eu",
-      implicitGlobalRegion: "eusc-de-east-1",
-      name: "aws-eusc",
+      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 GovCloud (US) global region"
+      },
+      "us-gov-east-1": {
+        description: "AWS GovCloud (US-East)"
+      },
+      "us-gov-west-1": {
+        description: "AWS GovCloud (US-West)"
       }
     }
   }, {
     id: "aws-iso",
     outputs: {
       dnsSuffix: "c2s.ic.gov",
-      dualStackDnsSuffix: "api.aws.ic.gov",
+      dualStackDnsSuffix: "c2s.ic.gov",
       implicitGlobalRegion: "us-iso-east-1",
       name: "aws-iso",
       supportsDualStack: false,
@@ -2246,7 +2070,7 @@ var partitions_default = {
     regionRegex: "^us\\-iso\\-\\w+\\-\\d+$",
     regions: {
       "aws-iso-global": {
-        description: "aws-iso global region"
+        description: "AWS ISO (US) global region"
       },
       "us-iso-east-1": {
         description: "US ISO East"
@@ -2259,7 +2083,7 @@ var partitions_default = {
     id: "aws-iso-b",
     outputs: {
       dnsSuffix: "sc2s.sgov.gov",
-      dualStackDnsSuffix: "api.aws.scloud",
+      dualStackDnsSuffix: "sc2s.sgov.gov",
       implicitGlobalRegion: "us-isob-east-1",
       name: "aws-iso-b",
       supportsDualStack: false,
@@ -2268,7 +2092,7 @@ var partitions_default = {
     regionRegex: "^us\\-isob\\-\\w+\\-\\d+$",
     regions: {
       "aws-iso-b-global": {
-        description: "aws-iso-b global region"
+        description: "AWS ISOB (US) global region"
       },
       "us-isob-east-1": {
         description: "US ISOB East (Ohio)"
@@ -2278,7 +2102,7 @@ var partitions_default = {
     id: "aws-iso-e",
     outputs: {
       dnsSuffix: "cloud.adc-e.uk",
-      dualStackDnsSuffix: "api.cloud-aws.adc-e.uk",
+      dualStackDnsSuffix: "cloud.adc-e.uk",
       implicitGlobalRegion: "eu-isoe-west-1",
       name: "aws-iso-e",
       supportsDualStack: false,
@@ -2287,7 +2111,7 @@ var partitions_default = {
     regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$",
     regions: {
       "aws-iso-e-global": {
-        description: "aws-iso-e global region"
+        description: "AWS ISOE (Europe) global region"
       },
       "eu-isoe-west-1": {
         description: "EU ISOE West"
@@ -2297,7 +2121,7 @@ var partitions_default = {
     id: "aws-iso-f",
     outputs: {
       dnsSuffix: "csp.hci.ic.gov",
-      dualStackDnsSuffix: "api.aws.hci.ic.gov",
+      dualStackDnsSuffix: "csp.hci.ic.gov",
       implicitGlobalRegion: "us-isof-south-1",
       name: "aws-iso-f",
       supportsDualStack: false,
@@ -2306,7 +2130,7 @@ var partitions_default = {
     regionRegex: "^us\\-isof\\-\\w+\\-\\d+$",
     regions: {
       "aws-iso-f-global": {
-        description: "aws-iso-f global region"
+        description: "AWS ISOF global region"
       },
       "us-isof-east-1": {
         description: "US ISOF EAST"
@@ -2316,25 +2140,19 @@ 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",
-      supportsDualStack: true,
+      dnsSuffix: "amazonaws.eu",
+      dualStackDnsSuffix: "amazonaws.eu",
+      implicitGlobalRegion: "eusc-de-east-1",
+      name: "aws-eusc",
+      supportsDualStack: false,
       supportsFIPS: true
     },
-    regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
+    regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$",
     regions: {
-      "aws-us-gov-global": {
-        description: "aws-us-gov global region"
-      },
-      "us-gov-east-1": {
-        description: "AWS GovCloud (US-East)"
-      },
-      "us-gov-west-1": {
-        description: "AWS GovCloud (US-West)"
+      "eusc-de-east-1": {
+        description: "EU (Germany)"
       }
     }
   }],
@@ -3462,6 +3280,20 @@ var getUserAgentPlugin = (config) => ({
   }
 });
 
+// node_modules/@smithy/config-resolver/dist-es/regionConfig/checkRegion.js
+var validRegions = /* @__PURE__ */ new Set();
+var checkRegion = (region, check = isValidHostLabel) => {
+  if (!validRegions.has(region) && !check(region)) {
+    if (region === "*") {
+      console.warn(`@smithy/config-resolver WARN - Please use the caller region instead of "*". See "sigv4a" in https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md.`);
+    } else {
+      throw new Error(`Region not accepted: region="${region}" is not a valid hostname component.`);
+    }
+  } else {
+    validRegions.add(region);
+  }
+};
+
 // node_modules/@smithy/config-resolver/dist-es/regionConfig/isFipsRegion.js
 var isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));
 
@@ -3476,11 +3308,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();
@@ -3811,6 +3642,7 @@ var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMED
 var NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND"];
 
 // node_modules/@smithy/service-error-classification/dist-es/index.js
+var isRetryableByTrait = (error) => error?.$retryable !== void 0;
 var isClockSkewCorrectedError = (error) => error.$metadata?.clockSkewCorrected;
 var isBrowserNetworkError = (error) => {
   const errorMessages = /* @__PURE__ */ new Set([
@@ -3827,7 +3659,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 || "") || 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 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;
@@ -3841,14 +3673,24 @@ var isServerError = (error) => {
 
 // node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js
 var DefaultRateLimiter = class _DefaultRateLimiter {
+  static setTimeoutFn = setTimeout;
+  beta;
+  minCapacity;
+  minFillRate;
+  scaleConstant;
+  smooth;
+  currentCapacity = 0;
+  enabled = false;
+  lastMaxRate = 0;
+  measuredTxRate = 0;
+  requestCount = 0;
+  fillRate;
+  lastThrottleTime;
+  lastTimestamp = 0;
+  lastTxRateBucket;
+  maxCapacity;
+  timeWindow = 0;
   constructor(options) {
-    this.currentCapacity = 0;
-    this.enabled = false;
-    this.lastMaxRate = 0;
-    this.measuredTxRate = 0;
-    this.requestCount = 0;
-    this.lastTimestamp = 0;
-    this.timeWindow = 0;
     this.beta = options?.beta ?? 0.7;
     this.minCapacity = options?.minCapacity ?? 1;
     this.minFillRate = options?.minFillRate ?? 0.5;
@@ -3937,7 +3779,6 @@ var DefaultRateLimiter = class _DefaultRateLimiter {
     return parseFloat(num.toFixed(8));
   }
 };
-DefaultRateLimiter.setTimeoutFn = setTimeout;
 
 // node_modules/@smithy/util-retry/dist-es/constants.js
 var DEFAULT_RETRY_DELAY_BASE = 100;
@@ -3979,11 +3820,13 @@ var createDefaultRetryToken = ({ retryDelay, retryCount, retryCost }) => {
 
 // node_modules/@smithy/util-retry/dist-es/StandardRetryStrategy.js
 var StandardRetryStrategy = class {
+  maxAttempts;
+  mode = RETRY_MODES.STANDARD;
+  capacity = INITIAL_RETRY_TOKENS;
+  retryBackoffStrategy = getDefaultRetryBackoffStrategy();
+  maxAttemptsProvider;
   constructor(maxAttempts) {
     this.maxAttempts = maxAttempts;
-    this.mode = RETRY_MODES.STANDARD;
-    this.capacity = INITIAL_RETRY_TOKENS;
-    this.retryBackoffStrategy = getDefaultRetryBackoffStrategy();
     this.maxAttemptsProvider = typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts;
   }
   async acquireInitialRetryToken(retryTokenScope) {
@@ -4037,9 +3880,12 @@ var StandardRetryStrategy = class {
 
 // node_modules/@smithy/util-retry/dist-es/AdaptiveRetryStrategy.js
 var AdaptiveRetryStrategy = class {
+  maxAttemptsProvider;
+  rateLimiter;
+  standardRetryStrategy;
+  mode = RETRY_MODES.ADAPTIVE;
   constructor(maxAttemptsProvider, options) {
     this.maxAttemptsProvider = maxAttemptsProvider;
-    this.mode = RETRY_MODES.ADAPTIVE;
     const { rateLimiter } = options ?? {};
     this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
     this.standardRetryStrategy = new StandardRetryStrategy(maxAttemptsProvider);
@@ -4137,7 +3983,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 {
@@ -4333,6 +4179,9 @@ var NODE_APP_ID_CONFIG_OPTIONS = {
 import { Buffer as Buffer2 } from "buffer";
 import { createHash, createHmac } from "crypto";
 var Hash = class {
+  algorithmIdentifier;
+  secret;
+  hash;
   constructor(algorithmIdentifier, secret) {
     this.algorithmIdentifier = algorithmIdentifier;
     this.secret = secret;
@@ -4362,7 +4211,7 @@ function castSourceData(toCast, encoding) {
 }
 
 // node_modules/@smithy/util-body-length-node/dist-es/calculateBodyLength.js
-import { fstatSync, lstatSync } from "fs";
+import { fstatSync, lstatSync, ReadStream } from "node:fs";
 var calculateBodyLength = (body) => {
   if (!body) {
     return 0;
@@ -4375,10 +4224,12 @@ 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}`);
 };
@@ -4443,7 +4294,7 @@ var inferPhysicalRegion = async () => {
   }
   if (!process.env[ENV_IMDS_DISABLED]) {
     try {
-      const { getInstanceMetadataEndpoint, httpRequest } = await import("./dist-es-DNTTNOP2.js");
+      const { getInstanceMetadataEndpoint, httpRequest } = await import("./dist-es-JPDE6SED.js");
       const endpoint = await getInstanceMetadataEndpoint();
       return (await httpRequest({ ...endpoint, path: IMDS_REGION_PATH })).toString();
     } catch (e) {
@@ -4475,22 +4326,33 @@ export {
   getHostHeaderPlugin,
   getLoggerPlugin,
   getRecursionDetectionPlugin,
+  Client,
+  toUint8Array,
+  collectBody,
+  extendedEncodeURIComponent,
   getSmithyContext,
   normalizeProvider,
+  Command,
+  SENSITIVE_STRING2 as SENSITIVE_STRING,
+  ServiceException,
+  decorateServiceException,
+  withBaseException,
+  loadConfigsForDefaultMode,
+  emitWarningIfUnsupportedVersion2 as emitWarningIfUnsupportedVersion,
+  getDefaultExtensionConfiguration,
+  resolveDefaultRuntimeConfig,
+  NoOpLogger,
   getHttpAuthSchemeEndpointRuleSetPlugin,
   getSerdePlugin,
   httpSigningMiddlewareOptions,
   getHttpSigningPlugin,
-  toUint8Array,
-  collectBody,
-  extendedEncodeURIComponent,
   DefaultIdentityProviderConfig,
   resolveUserAgentConfig,
   EndpointCache,
   customEndpointFunctions,
   resolveEndpoint,
   awsEndpointFunctions,
-  emitWarningIfUnsupportedVersion,
+  emitWarningIfUnsupportedVersion as emitWarningIfUnsupportedVersion2,
   setFeature2 as setFeature,
   AwsSdkSigV4Signer,
   AwsSdkSigV4ASigner,
@@ -4499,17 +4361,6 @@ export {
   NODE_SIGV4A_CONFIG_OPTIONS,
   SignatureV4,
   resolveAwsSdkSigV4Config,
-  Client,
-  Command,
-  SENSITIVE_STRING2 as SENSITIVE_STRING,
-  ServiceException,
-  decorateServiceException,
-  withBaseException,
-  loadConfigsForDefaultMode,
-  emitWarningIfUnsupportedVersion2,
-  getDefaultExtensionConfiguration,
-  resolveDefaultRuntimeConfig,
-  NoOpLogger,
   collectBodyString,
   getUserAgentPlugin,
   booleanSelector,
@@ -4536,4 +4387,4 @@ export {
   getAwsRegionExtensionConfiguration,
   resolveAwsRegionExtensionConfiguration
 };
-//# sourceMappingURL=chunk-COGWOFTA.js.map
+//# sourceMappingURL=chunk-HR3W7R4B.js.map