@larkup/cli 0.2.25 → 0.2.26

package/dist/chunk-MACWQEJS.js

@@ -0,0 +1,2091 @@
+// ../../node_modules/.pnpm/@smithy+types@4.17.2/node_modules/@smithy/types/dist-es/extensions/checksum.js
+var AlgorithmId;
+(function(AlgorithmId2) {
+  AlgorithmId2["MD5"] = "md5";
+  AlgorithmId2["CRC32"] = "crc32";
+  AlgorithmId2["CRC32C"] = "crc32c";
+  AlgorithmId2["SHA1"] = "sha1";
+  AlgorithmId2["SHA256"] = "sha256";
+})(AlgorithmId || (AlgorithmId = {}));
+
+// ../../node_modules/.pnpm/@smithy+types@4.17.2/node_modules/@smithy/types/dist-es/middleware.js
+var SMITHY_CONTEXT_KEY = "__smithy_context";
+
+// ../../node_modules/.pnpm/@smithy+types@4.17.2/node_modules/@smithy/types/dist-es/endpoint.js
+var EndpointURLScheme;
+(function(EndpointURLScheme2) {
+  EndpointURLScheme2["HTTP"] = "http";
+  EndpointURLScheme2["HTTPS"] = "https";
+})(EndpointURLScheme || (EndpointURLScheme = {}));
+
+// ../../node_modules/.pnpm/@smithy+types@4.17.2/node_modules/@smithy/types/dist-es/profile.js
+var IniSectionType;
+(function(IniSectionType2) {
+  IniSectionType2["PROFILE"] = "profile";
+  IniSectionType2["SSO_SESSION"] = "sso-session";
+  IniSectionType2["SERVICES"] = "services";
+})(IniSectionType || (IniSectionType = {}));
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/getSmithyContext.js
+var getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/hasOwn.js
+function hasOwn(o, k) {
+  return Object.prototype.hasOwnProperty.call(o, k);
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/httpRequest.js
+var HttpRequest = class _HttpRequest {
+  method;
+  protocol;
+  hostname;
+  port;
+  path;
+  query;
+  headers;
+  username;
+  password;
+  fragment;
+  body;
+  constructor(options) {
+    this.method = options.method || "GET";
+    this.hostname = options.hostname || "localhost";
+    this.port = options.port;
+    this.query = options.query || {};
+    this.headers = options.headers || {};
+    this.body = options.body;
+    this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
+    this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
+    this.username = options.username;
+    this.password = options.password;
+    this.fragment = options.fragment;
+  }
+  static clone(request) {
+    const cloned = new _HttpRequest({
+      ...request,
+      headers: { ...request.headers }
+    });
+    if (cloned.query) {
+      cloned.query = cloneQuery(cloned.query);
+    }
+    return cloned;
+  }
+  static isInstance(request) {
+    if (!request) {
+      return false;
+    }
+    const req = request;
+    return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
+  }
+  clone() {
+    return _HttpRequest.clone(this);
+  }
+};
+function cloneQuery(query) {
+  return Object.keys(query).reduce((carry, paramName) => {
+    const param = query[paramName];
+    return {
+      ...carry,
+      [paramName]: Array.isArray(param) ? [...param] : param
+    };
+  }, {});
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/normalizeProvider.js
+var normalizeProvider = (input) => {
+  if (typeof input === "function")
+    return input;
+  const promisified = Promise.resolve(input);
+  return () => promisified;
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/parseQueryString.js
+function parseQueryString(querystring) {
+  const query = {};
+  querystring = querystring.replace(/^\?/, "");
+  if (querystring) {
+    for (const pair of querystring.split("&")) {
+      let [key, value = null] = pair.split("=");
+      key = decodeURIComponent(key);
+      if (value) {
+        value = decodeURIComponent(value);
+      }
+      if (!(key in query)) {
+        query[key] = value;
+      } else if (Array.isArray(query[key])) {
+        query[key].push(value);
+      } else {
+        query[key] = [query[key], value];
+      }
+    }
+  }
+  return query;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/parseUrl.js
+var parseUrl = (url) => {
+  if (typeof url === "string") {
+    return parseUrl(new URL(url));
+  }
+  const { hostname, pathname, port, protocol, search } = url;
+  let query;
+  if (search) {
+    query = parseQueryString(search);
+  }
+  return {
+    hostname,
+    port: port ? parseInt(port) : void 0,
+    protocol,
+    path: pathname,
+    query
+  };
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/httpResponse.js
+var HttpResponse = class {
+  statusCode;
+  reason;
+  headers;
+  body;
+  constructor(options) {
+    this.statusCode = options.statusCode;
+    this.reason = options.reason;
+    this.headers = options.headers || {};
+    this.body = options.body;
+  }
+  static isInstance(response) {
+    if (!response)
+      return false;
+    const resp = response;
+    return typeof resp.statusCode === "number" && typeof resp.headers === "object";
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/isValidHostLabel.js
+var VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
+var isValidHostLabel = (value, allowSubDomains = false) => {
+  if (!allowSubDomains) {
+    return VALID_HOST_LABEL_REGEX.test(value);
+  }
+  const labels = value.split(".");
+  for (const label of labels) {
+    if (!isValidHostLabel(label)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/isValidHostname.js
+function isValidHostname(hostname) {
+  const hostPattern = /^[a-z0-9][a-z0-9.-]*[a-z0-9]$/;
+  return hostPattern.test(hostname);
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/toEndpointV1.js
+var toEndpointV1 = (endpoint) => {
+  if (typeof endpoint === "object") {
+    if ("url" in endpoint) {
+      const v1Endpoint = parseUrl(endpoint.url);
+      if (endpoint.headers) {
+        v1Endpoint.headers = {};
+        for (const name in endpoint.headers) {
+          if (!hasOwn(endpoint.headers, name))
+            continue;
+          v1Endpoint.headers[name.toLowerCase()] = endpoint.headers[name].join(", ");
+        }
+      }
+      return v1Endpoint;
+    }
+    return endpoint;
+  }
+  return parseUrl(endpoint);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/schemas/operation.js
+var operation = (namespace, name, traits, input, output) => ({
+  name,
+  namespace,
+  traits,
+  input,
+  output
+});
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js
+var schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
+  const { response } = await next(args);
+  const { operationSchema } = getSmithyContext(context);
+  const [, ns, n, t, i, o] = operationSchema ?? [];
+  try {
+    const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
+      ...config,
+      ...context
+    }, response);
+    return {
+      response,
+      output: parsed
+    };
+  } catch (error) {
+    Object.defineProperty(error, "$response", {
+      value: response,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+    if (!("$metadata" in error)) {
+      const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
+      try {
+        error.message += "\n  " + hint;
+      } catch (ignored) {
+        if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
+          console.warn(hint);
+        } else {
+          context.logger?.warn?.(hint);
+        }
+      }
+      if (typeof error.$responseBodyText !== "undefined") {
+        if (error.$response) {
+          error.$response.body = error.$responseBodyText;
+        }
+      }
+      try {
+        if (HttpResponse.isInstance(response)) {
+          const { headers = {}, statusCode } = response;
+          const headerEntries = Object.entries(headers);
+          error.$metadata = {
+            httpStatusCode: statusCode,
+            requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
+            extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
+            cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
+          };
+        }
+      } catch (ignored) {
+      }
+    }
+    throw error;
+  }
+};
+var findHeader = (pattern, headers) => {
+  return (headers.find(([k]) => {
+    return k.match(pattern);
+  }) || [void 0, void 0])[1];
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js
+var schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
+  const { operationSchema } = getSmithyContext(context);
+  const [, ns, n, t, i, o] = operationSchema ?? [];
+  const endpoint = context.endpointV2 ? async () => toEndpointV1(context.endpointV2) : config.endpoint;
+  const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
+    ...config,
+    ...context,
+    endpoint
+  });
+  return next({
+    ...args,
+    request
+  });
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js
+var deserializerMiddlewareOption = {
+  name: "deserializerMiddleware",
+  step: "deserialize",
+  tags: ["DESERIALIZER"],
+  override: true
+};
+var serializerMiddlewareOption = {
+  name: "serializerMiddleware",
+  step: "serialize",
+  tags: ["SERIALIZER"],
+  override: true
+};
+function getSchemaSerdePlugin(config) {
+  return {
+    applyToStack: (commandStack) => {
+      commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
+      commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
+      config.protocol.setSerdeContext(config);
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js
+var TypeRegistry = class _TypeRegistry {
+  namespace;
+  schemas;
+  exceptions;
+  static registries = /* @__PURE__ */ new Map();
+  constructor(namespace, schemas = /* @__PURE__ */ new Map(), exceptions = /* @__PURE__ */ new Map()) {
+    this.namespace = namespace;
+    this.schemas = schemas;
+    this.exceptions = exceptions;
+  }
+  static for(namespace) {
+    if (!_TypeRegistry.registries.has(namespace)) {
+      _TypeRegistry.registries.set(namespace, new _TypeRegistry(namespace));
+    }
+    return _TypeRegistry.registries.get(namespace);
+  }
+  copyFrom(other) {
+    const { schemas, exceptions } = this;
+    for (const [k, v] of other.schemas) {
+      if (!schemas.has(k)) {
+        schemas.set(k, v);
+      }
+    }
+    for (const [k, v] of other.exceptions) {
+      if (!exceptions.has(k)) {
+        exceptions.set(k, v);
+      }
+    }
+  }
+  register(shapeId, schema) {
+    const qualifiedName = this.normalizeShapeId(shapeId);
+    for (const r of [this, _TypeRegistry.for(qualifiedName.split("#")[0])]) {
+      r.schemas.set(qualifiedName, schema);
+    }
+  }
+  getSchema(shapeId) {
+    const id = this.normalizeShapeId(shapeId);
+    if (!this.schemas.has(id)) {
+      if (!shapeId.includes("#")) {
+        const suffix = "#" + shapeId;
+        const candidates = [];
+        for (const [shapeId2, schema] of this.schemas.entries()) {
+          if (shapeId2.endsWith(suffix)) {
+            candidates.push(schema);
+          }
+        }
+        if (candidates.length === 1) {
+          return candidates[0];
+        }
+      }
+      throw new Error(`@smithy/core/schema - schema not found for ${id}`);
+    }
+    return this.schemas.get(id);
+  }
+  registerError(es, ctor) {
+    const $error = es;
+    const ns = $error[1];
+    for (const r of [this, _TypeRegistry.for(ns)]) {
+      r.schemas.set(ns + "#" + $error[2], $error);
+      r.exceptions.set($error, ctor);
+    }
+  }
+  getErrorCtor(es) {
+    const $error = es;
+    if (this.exceptions.has($error)) {
+      return this.exceptions.get($error);
+    }
+    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) {
+    for (const schema of this.schemas.values()) {
+      if (predicate(schema)) {
+        return schema;
+      }
+    }
+    return void 0;
+  }
+  clear() {
+    this.schemas.clear();
+    this.exceptions.clear();
+  }
+  normalizeShapeId(shapeId) {
+    if (shapeId.includes("#")) {
+      return shapeId;
+    }
+    return this.namespace + "#" + shapeId;
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/deref.js
+var deref = (schemaRef) => {
+  if (typeof schemaRef === "function") {
+    return schemaRef();
+  }
+  return schemaRef;
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/schemas/translateTraits.js
+var traitsCache = [];
+function translateTraits(indicator) {
+  if (typeof indicator === "object") {
+    return indicator;
+  }
+  indicator = indicator | 0;
+  if (traitsCache[indicator]) {
+    return traitsCache[indicator];
+  }
+  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 traitsCache[indicator] = traits;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js
+var anno = {
+  it: Symbol.for("@smithy/nor-struct-it"),
+  ns: Symbol.for("@smithy/ns")
+};
+var simpleSchemaCacheN = [];
+var simpleSchemaCacheS = {};
+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 keyAble = typeof ref === "function" || typeof ref === "object" && ref !== null;
+    if (typeof ref === "number") {
+      if (simpleSchemaCacheN[ref]) {
+        return simpleSchemaCacheN[ref];
+      }
+    } else if (typeof ref === "string") {
+      if (simpleSchemaCacheS[ref]) {
+        return simpleSchemaCacheS[ref];
+      }
+    } else if (keyAble) {
+      if (ref[anno.ns]) {
+        return ref[anno.ns];
+      }
+    }
+    const sc = deref(ref);
+    if (sc instanceof _NormalizedSchema) {
+      return sc;
+    }
+    if (isMemberSchema(sc)) {
+      const [ns2, traits] = sc;
+      if (ns2 instanceof _NormalizedSchema) {
+        Object.assign(ns2.getMergedTraits(), translateTraits(traits));
+        return ns2;
+      }
+      throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`);
+    }
+    const ns = new _NormalizedSchema(sc);
+    if (keyAble) {
+      return ref[anno.ns] = ns;
+    }
+    if (typeof sc === "string") {
+      return simpleSchemaCacheS[sc] = ns;
+    }
+    if (typeof sc === "number") {
+      return simpleSchemaCacheN[sc] = ns;
+    }
+    return ns;
+  }
+  getSchema() {
+    const sc = this.schema;
+    if (Array.isArray(sc) && 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();
+    if (typeof sc !== "object") {
+      return false;
+    }
+    const id = sc[0];
+    return id === 3 || id === -3 || id === 4;
+  }
+  isUnionSchema() {
+    const sc = this.getSchema();
+    if (typeof sc !== "object") {
+      return false;
+    }
+    return sc[0] === 4;
+  }
+  isBlobSchema() {
+    const sc = this.getSchema();
+    return sc === 21 || sc === 42;
+  }
+  isTimestampSchema() {
+    const sc = this.getSchema();
+    return typeof sc === "number" && sc >= 4 && sc <= 7;
+  }
+  isUnitSchema() {
+    return this.getSchema() === "unit";
+  }
+  isDocumentSchema() {
+    return this.getSchema() === 15;
+  }
+  isStringSchema() {
+    return this.getSchema() === 0;
+  }
+  isBooleanSchema() {
+    return this.getSchema() === 2;
+  }
+  isNumericSchema() {
+    return this.getSchema() === 1;
+  }
+  isBigIntegerSchema() {
+    return this.getSchema() === 17;
+  }
+  isBigDecimalSchema() {
+    return this.getSchema() === 19;
+  }
+  isStreaming() {
+    const { streaming } = this.getMergedTraits();
+    return !!streaming || this.getSchema() === 42;
+  }
+  isIdempotencyToken() {
+    return !!this.getMergedTraits().idempotencyToken;
+  }
+  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 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();
+    const z = struct[4].length;
+    let it = struct[anno.it];
+    if (it && z === it.length) {
+      yield* it;
+      return;
+    }
+    it = Array(z);
+    for (let i = 0; i < z; ++i) {
+      const k = struct[4][i];
+      const v = member([struct[5][i], 0], k);
+      yield it[i] = [k, v];
+    }
+    struct[anno.it] = it;
+  }
+};
+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/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/is-array-buffer/is-array-buffer.js
+var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-buffer-from/buffer-from.js
+var fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
+  if (!isArrayBuffer(input)) {
+    throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
+  }
+  return Buffer.from(input, offset, length);
+};
+var fromString = (input, encoding) => {
+  if (typeof input !== "string") {
+    throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+  }
+  return encoding ? Buffer.from(input, encoding) : Buffer.from(input);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/fromUtf8.js
+var fromUtf8 = (input) => {
+  const buf = fromString(input, "utf8");
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUtf8.js
+var toUtf8 = (input) => {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+    throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+  }
+  return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-hex-encoding/hex-encoding.js
+var SHORT_TO_HEX = {};
+var HEX_TO_SHORT = {};
+for (let i = 0; i < 256; i++) {
+  let encodedByte = i.toString(16).toLowerCase();
+  if (encodedByte.length === 1) {
+    encodedByte = `0${encodedByte}`;
+  }
+  SHORT_TO_HEX[i] = encodedByte;
+  HEX_TO_SHORT[encodedByte] = i;
+}
+function fromHex(encoded) {
+  if (encoded.length % 2 !== 0) {
+    throw new Error("Hex encoded strings must have an even number length");
+  }
+  const out = new Uint8Array(encoded.length / 2);
+  for (let i = 0; i < encoded.length; i += 2) {
+    const encodedByte = encoded.slice(i, i + 2).toLowerCase();
+    if (encodedByte in HEX_TO_SHORT) {
+      out[i / 2] = HEX_TO_SHORT[encodedByte];
+    } else {
+      throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
+    }
+  }
+  return out;
+}
+function toHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    out += SHORT_TO_HEX[bytes[i]];
+  }
+  return out;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/index.js
+import { getRandomValues } from "crypto";
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/fromBase64.js
+var BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
+var fromBase64 = (input) => {
+  if (input.length * 3 % 4 !== 0) {
+    throw new TypeError(`Incorrect padding on base64 string.`);
+  }
+  if (!BASE64_REGEX.exec(input)) {
+    throw new TypeError(`Invalid base64 string.`);
+  }
+  const buffer = fromString(input, "base64");
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/toBase64.js
+var toBase64 = (_input) => {
+  let input;
+  if (typeof _input === "string") {
+    input = fromUtf8(_input);
+  } else {
+    input = _input;
+  }
+  if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+    throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+  }
+  return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("base64");
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/blob/Uint8ArrayBlobAdapter.js
+function bindUint8ArrayBlobAdapter(toUtf83, fromUtf83, toBase643, fromBase642) {
+  return class Uint8ArrayBlobAdapter2 extends Uint8Array {
+    static fromString(source, encoding = "utf-8") {
+      if (typeof source === "string") {
+        if (encoding === "base64") {
+          return Uint8ArrayBlobAdapter2.mutate(fromBase642(source));
+        }
+        return Uint8ArrayBlobAdapter2.mutate(fromUtf83(source));
+      }
+      throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+    }
+    static mutate(source) {
+      Object.setPrototypeOf(source, Uint8ArrayBlobAdapter2.prototype);
+      return source;
+    }
+    transformToString(encoding = "utf-8") {
+      if (encoding === "base64") {
+        return toBase643(this);
+      }
+      return toUtf83(this);
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/uuid/v4.js
+var decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bindV4(getRandomValues2) {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return () => crypto.randomUUID();
+  }
+  return () => {
+    const rnds = new Uint8Array(16);
+    getRandomValues2(rnds);
+    rnds[6] = rnds[6] & 15 | 64;
+    rnds[8] = rnds[8] & 63 | 128;
+    return decimalToHex[rnds[0]] + decimalToHex[rnds[1]] + decimalToHex[rnds[2]] + decimalToHex[rnds[3]] + "-" + decimalToHex[rnds[4]] + decimalToHex[rnds[5]] + "-" + decimalToHex[rnds[6]] + decimalToHex[rnds[7]] + "-" + decimalToHex[rnds[8]] + decimalToHex[rnds[9]] + "-" + decimalToHex[rnds[10]] + decimalToHex[rnds[11]] + decimalToHex[rnds[12]] + decimalToHex[rnds[13]] + decimalToHex[rnds[14]] + decimalToHex[rnds[15]];
+  };
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/parse-utils.js
+var expectNumber = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    if (!Number.isNaN(parsed)) {
+      if (String(parsed) !== String(value)) {
+        logger.warn(stackTraceWarning(`Expected number but observed string: ${value}`));
+      }
+      return parsed;
+    }
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  throw new TypeError(`Expected number, got ${typeof value}: ${value}`);
+};
+var MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
+var expectFloat32 = (value) => {
+  const expected = expectNumber(value);
+  if (expected !== void 0 && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) {
+    if (Math.abs(expected) > MAX_FLOAT) {
+      throw new TypeError(`Expected 32-bit float, got ${value}`);
+    }
+  }
+  return expected;
+};
+var expectLong = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (Number.isInteger(value) && !Number.isNaN(value)) {
+    return value;
+  }
+  throw new TypeError(`Expected integer, got ${typeof value}: ${value}`);
+};
+var expectShort = (value) => expectSizedInt(value, 16);
+var expectByte = (value) => expectSizedInt(value, 8);
+var expectSizedInt = (value, size) => {
+  const expected = expectLong(value);
+  if (expected !== void 0 && castInt(expected, size) !== expected) {
+    throw new TypeError(`Expected ${size}-bit integer, got ${value}`);
+  }
+  return expected;
+};
+var castInt = (value, size) => {
+  switch (size) {
+    case 32:
+      return Int32Array.of(value)[0];
+    case 16:
+      return Int16Array.of(value)[0];
+    case 8:
+      return Int8Array.of(value)[0];
+  }
+};
+var strictParseDouble = (value) => {
+  if (typeof value == "string") {
+    return expectNumber(parseNumber(value));
+  }
+  return expectNumber(value);
+};
+var strictParseFloat32 = (value) => {
+  if (typeof value == "string") {
+    return expectFloat32(parseNumber(value));
+  }
+  return expectFloat32(value);
+};
+var NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g;
+var parseNumber = (value) => {
+  const matches = value.match(NUMBER_REGEX);
+  if (matches === null || matches[0].length !== value.length) {
+    throw new TypeError(`Expected real number, got implicit NaN`);
+  }
+  return parseFloat(value);
+};
+var strictParseShort = (value) => {
+  if (typeof value === "string") {
+    return expectShort(parseNumber(value));
+  }
+  return expectShort(value);
+};
+var strictParseByte = (value) => {
+  if (typeof value === "string") {
+    return expectByte(parseNumber(value));
+  }
+  return expectByte(value);
+};
+var stackTraceWarning = (message) => {
+  return String(new TypeError(message).stack || message).split("\n").slice(0, 5).filter((s) => !s.includes("stackTraceWarning")).join("\n");
+};
+var logger = {
+  warn: console.warn
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/date-utils.js
+var DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function dateToUtcString(date2) {
+  const year2 = date2.getUTCFullYear();
+  const month = date2.getUTCMonth();
+  const dayOfWeek = date2.getUTCDay();
+  const dayOfMonthInt = date2.getUTCDate();
+  const hoursInt = date2.getUTCHours();
+  const minutesInt = date2.getUTCMinutes();
+  const secondsInt = date2.getUTCSeconds();
+  const dayOfMonthString = dayOfMonthInt < 10 ? `0${dayOfMonthInt}` : `${dayOfMonthInt}`;
+  const hoursString = hoursInt < 10 ? `0${hoursInt}` : `${hoursInt}`;
+  const minutesString = minutesInt < 10 ? `0${minutesInt}` : `${minutesInt}`;
+  const secondsString = secondsInt < 10 ? `0${secondsInt}` : `${secondsInt}`;
+  return `${DAYS[dayOfWeek]}, ${dayOfMonthString} ${MONTHS[month]} ${year2} ${hoursString}:${minutesString}:${secondsString} GMT`;
+}
+var RFC3339 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/);
+var parseRfc3339DateTime = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC-3339 date-times must be expressed as strings");
+  }
+  const match = RFC3339.exec(value);
+  if (!match) {
+    throw new TypeError("Invalid RFC-3339 date-time value");
+  }
+  const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds] = match;
+  const year2 = strictParseShort(stripLeadingZeroes(yearStr));
+  const month = parseDateValue(monthStr, "month", 1, 12);
+  const day = parseDateValue(dayStr, "day", 1, 31);
+  return buildDate(year2, month, day, { hours, minutes, seconds, fractionalMilliseconds });
+};
+var RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}:\d{2})|[zZ])$/);
+var parseRfc3339DateTimeWithOffset = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC-3339 date-times must be expressed as strings");
+  }
+  const match = RFC3339_WITH_OFFSET.exec(value);
+  if (!match) {
+    throw new TypeError("Invalid RFC-3339 date-time value");
+  }
+  const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, offsetStr] = match;
+  const year2 = strictParseShort(stripLeadingZeroes(yearStr));
+  const month = parseDateValue(monthStr, "month", 1, 12);
+  const day = parseDateValue(dayStr, "day", 1, 31);
+  const date2 = buildDate(year2, month, day, { hours, minutes, seconds, fractionalMilliseconds });
+  if (offsetStr.toUpperCase() != "Z") {
+    date2.setTime(date2.getTime() - parseOffsetToMilliseconds(offsetStr));
+  }
+  return date2;
+};
+var IMF_FIXDATE = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
+var RFC_850_DATE = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
+var ASC_TIME = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
+var parseRfc7231DateTime = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError("RFC-7231 date-times must be expressed as strings");
+  }
+  let match = IMF_FIXDATE.exec(value);
+  if (match) {
+    const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
+    return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
+  }
+  match = RFC_850_DATE.exec(value);
+  if (match) {
+    const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
+    return adjustRfc850Year(buildDate(parseTwoDigitYear(yearStr), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), {
+      hours,
+      minutes,
+      seconds,
+      fractionalMilliseconds
+    }));
+  }
+  match = ASC_TIME.exec(value);
+  if (match) {
+    const [_, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, yearStr] = match;
+    return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr.trimLeft(), "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
+  }
+  throw new TypeError("Invalid RFC-7231 date-time value");
+};
+var parseEpochTimestamp = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  let valueAsDouble;
+  if (typeof value === "number") {
+    valueAsDouble = value;
+  } else if (typeof value === "string") {
+    valueAsDouble = strictParseDouble(value);
+  } else if (typeof value === "object" && value.tag === 1) {
+    valueAsDouble = value.value;
+  } else {
+    throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
+  }
+  if (Number.isNaN(valueAsDouble) || valueAsDouble === Infinity || valueAsDouble === -Infinity) {
+    throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
+  }
+  return new Date(Math.round(valueAsDouble * 1e3));
+};
+var buildDate = (year2, month, day, time2) => {
+  const adjustedMonth = month - 1;
+  validateDayOfMonth(year2, adjustedMonth, day);
+  return new Date(Date.UTC(year2, adjustedMonth, day, parseDateValue(time2.hours, "hour", 0, 23), parseDateValue(time2.minutes, "minute", 0, 59), parseDateValue(time2.seconds, "seconds", 0, 60), parseMilliseconds(time2.fractionalMilliseconds)));
+};
+var parseTwoDigitYear = (value) => {
+  const thisYear = (/* @__PURE__ */ new Date()).getUTCFullYear();
+  const valueInThisCentury = Math.floor(thisYear / 100) * 100 + strictParseShort(stripLeadingZeroes(value));
+  if (valueInThisCentury < thisYear) {
+    return valueInThisCentury + 100;
+  }
+  return valueInThisCentury;
+};
+var FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1e3;
+var adjustRfc850Year = (input) => {
+  if (input.getTime() - (/* @__PURE__ */ new Date()).getTime() > FIFTY_YEARS_IN_MILLIS) {
+    return new Date(Date.UTC(input.getUTCFullYear() - 100, input.getUTCMonth(), input.getUTCDate(), input.getUTCHours(), input.getUTCMinutes(), input.getUTCSeconds(), input.getUTCMilliseconds()));
+  }
+  return input;
+};
+var parseMonthByShortName = (value) => {
+  const monthIdx = MONTHS.indexOf(value);
+  if (monthIdx < 0) {
+    throw new TypeError(`Invalid month: ${value}`);
+  }
+  return monthIdx + 1;
+};
+var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var validateDayOfMonth = (year2, month, day) => {
+  let maxDays = DAYS_IN_MONTH[month];
+  if (month === 1 && isLeapYear(year2)) {
+    maxDays = 29;
+  }
+  if (day > maxDays) {
+    throw new TypeError(`Invalid day for ${MONTHS[month]} in ${year2}: ${day}`);
+  }
+};
+var isLeapYear = (year2) => {
+  return year2 % 4 === 0 && (year2 % 100 !== 0 || year2 % 400 === 0);
+};
+var parseDateValue = (value, type, lower, upper) => {
+  const dateVal = strictParseByte(stripLeadingZeroes(value));
+  if (dateVal < lower || dateVal > upper) {
+    throw new TypeError(`${type} must be between ${lower} and ${upper}, inclusive`);
+  }
+  return dateVal;
+};
+var parseMilliseconds = (value) => {
+  if (value === null || value === void 0) {
+    return 0;
+  }
+  return strictParseFloat32("0." + value) * 1e3;
+};
+var parseOffsetToMilliseconds = (value) => {
+  const directionStr = value[0];
+  let direction = 1;
+  if (directionStr == "+") {
+    direction = 1;
+  } else if (directionStr == "-") {
+    direction = -1;
+  } else {
+    throw new TypeError(`Offset direction, ${directionStr}, must be "+" or "-"`);
+  }
+  const hour = Number(value.substring(1, 3));
+  const minute = Number(value.substring(4, 6));
+  return direction * (hour * 60 + minute) * 60 * 1e3;
+};
+var stripLeadingZeroes = (value) => {
+  let idx = 0;
+  while (idx < value.length - 1 && value.charAt(idx) === "0") {
+    idx++;
+  }
+  if (idx === 0) {
+    return value;
+  }
+  return value.slice(idx);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/lazy-json.js
+var LazyJsonString = function LazyJsonString2(val) {
+  const str = Object.assign(new String(val), {
+    deserializeJSON() {
+      return JSON.parse(String(val));
+    },
+    toString() {
+      return String(val);
+    },
+    toJSON() {
+      return String(val);
+    }
+  });
+  return str;
+};
+LazyJsonString.from = (object) => {
+  if (object && typeof object === "object" && (object instanceof LazyJsonString || "deserializeJSON" in object)) {
+    return object;
+  } else if (typeof object === "string" || Object.getPrototypeOf(object) === String.prototype) {
+    return LazyJsonString(String(object));
+  }
+  return LazyJsonString(JSON.stringify(object));
+};
+LazyJsonString.fromObject = LazyJsonString.from;
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/quote-header.js
+function quoteHeader(part) {
+  if (part.includes(",") || part.includes('"')) {
+    part = `"${part.replace(/"/g, '\\"')}"`;
+  }
+  return part;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/schema-serde-lib/schema-date-utils.js
+var ddd = `(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)(?:[ne|u?r]?s?day)?`;
+var mmm = `(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)`;
+var time = `(\\d?\\d):(\\d{2}):(\\d{2})(?:\\.(\\d+))?`;
+var date = `(\\d?\\d)`;
+var year = `(\\d{4})`;
+var RFC3339_WITH_OFFSET2 = new RegExp(/^(\d{4})-(\d\d)-(\d\d)[tT](\d\d):(\d\d):(\d\d)(\.(\d+))?(([-+]\d\d:\d\d)|[zZ])$/);
+var IMF_FIXDATE2 = new RegExp(`^${ddd}, ${date} ${mmm} ${year} ${time} GMT$`);
+var RFC_850_DATE2 = new RegExp(`^${ddd}, ${date}-${mmm}-(\\d\\d) ${time} GMT$`);
+var ASC_TIME2 = 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_OFFSET2.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_FIXDATE2.exec(value)) {
+    [, day, month, year2, hour, minute, second, fraction] = matches;
+  } else if (matches = RFC_850_DATE2.exec(value)) {
+    [, day, month, year2, hour, minute, second, fraction] = matches;
+    year2 = (Number(year2) + 1900).toString();
+  } else if (matches = ASC_TIME2.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}]`);
+  }
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/split-every.js
+function splitEvery(value, delimiter, numDelimiters) {
+  if (numDelimiters <= 0 || !Number.isInteger(numDelimiters)) {
+    throw new Error("Invalid number of delimiters (" + numDelimiters + ") for splitEvery.");
+  }
+  const segments = value.split(delimiter);
+  if (numDelimiters === 1) {
+    return segments;
+  }
+  const compoundSegments = [];
+  let currentSegment = "";
+  for (let i = 0; i < segments.length; i++) {
+    if (currentSegment === "") {
+      currentSegment = segments[i];
+    } else {
+      currentSegment += delimiter + segments[i];
+    }
+    if ((i + 1) % numDelimiters === 0) {
+      compoundSegments.push(currentSegment);
+      currentSegment = "";
+    }
+  }
+  if (currentSegment !== "") {
+    compoundSegments.push(currentSegment);
+  }
+  return compoundSegments;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/split-header.js
+var splitHeader = (value) => {
+  const z = value.length;
+  const values = [];
+  let withinQuotes = false;
+  let prevChar = void 0;
+  let anchor = 0;
+  for (let i = 0; i < z; ++i) {
+    const char = value[i];
+    switch (char) {
+      case `"`:
+        if (prevChar !== "\\") {
+          withinQuotes = !withinQuotes;
+        }
+        break;
+      case ",":
+        if (!withinQuotes) {
+          values.push(value.slice(anchor, i));
+          anchor = i + 1;
+        }
+        break;
+      default:
+    }
+    prevChar = char;
+  }
+  values.push(value.slice(anchor));
+  return values.map((v) => {
+    v = v.trim();
+    const z2 = v.length;
+    if (z2 < 2) {
+      return v;
+    }
+    if (v[0] === `"` && v[z2 - 1] === `"`) {
+      v = v.slice(1, z2 - 1);
+    }
+    return v.replace(/\\"/g, '"');
+  });
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js
+var format = /^-?((0|[1-9]\d*)(\.\d+)?|\.\d+)([eE][+-]?\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 string must conform to the Smithy bigDecimal format. Received: "${string}"`);
+    }
+  }
+  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);
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-body-length/calculateBodyLength.js
+import { ReadStream, fstatSync, lstatSync } from "fs";
+var calculateBodyLength = (body) => {
+  if (!body) {
+    return 0;
+  }
+  if (typeof body === "string") {
+    return Buffer.byteLength(body);
+  } else if (typeof body.byteLength === "number") {
+    return body.byteLength;
+  } else if (typeof body.size === "number") {
+    return body.size;
+  } else if (typeof body.start === "number" && typeof body.end === "number") {
+    return body.end + 1 - body.start;
+  } else if (body instanceof ReadStream) {
+    if (body.path != null) {
+      return lstatSync(body.path).size;
+    } else if (typeof body.fd === "number") {
+      return fstatSync(body.fd).size;
+    }
+  }
+  throw new Error(`Body Length computation failed for ${body}`);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUint8Array.js
+var toUint8Array = (data) => {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (typeof data === "string") {
+    return fromUtf8(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+  }
+  return new Uint8Array(data);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/concatBytes.js
+function concatBytes(arrays, length) {
+  if (length === void 0) {
+    length = 0;
+    for (const bytes of arrays) {
+      length += bytes.byteLength;
+    }
+  }
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const buf of arrays) {
+    result.set(buf, offset);
+    offset += buf.byteLength;
+  }
+  return result;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.js
+import { Readable } from "stream";
+var ChecksumStream = class extends Readable {
+  expectedChecksum;
+  checksumSourceLocation;
+  checksum;
+  source;
+  base64Encoder;
+  constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) {
+    super();
+    if (typeof source.pipe !== "function") {
+      throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
+    }
+    this.source = source;
+    this.base64Encoder = base64Encoder ?? toBase64;
+    this.expectedChecksum = expectedChecksum;
+    this.checksum = checksum;
+    this.checksumSourceLocation = checksumSourceLocation;
+    this.source.on("data", this.onSourceData);
+    this.source.on("end", this.onSourceEnd);
+    this.source.on("error", this.onSourceError);
+    this.source.on("close", this.onSourceClose);
+    this.source.pause();
+  }
+  onSourceData = (chunk) => {
+    if (this.destroyed) {
+      return;
+    }
+    try {
+      this.checksum.update(chunk);
+    } catch (e) {
+      this.destroy(e);
+      return;
+    }
+    if (!this.push(chunk)) {
+      this.source.pause();
+    }
+  };
+  onSourceEnd = async () => {
+    if (this.destroyed) {
+      return;
+    }
+    try {
+      const digest = await this.checksum.digest();
+      const received = this.base64Encoder(digest);
+      if (this.expectedChecksum !== received) {
+        this.destroy(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}" in response header "${this.checksumSourceLocation}".`));
+        return;
+      }
+    } catch (e) {
+      this.destroy(e);
+      return;
+    }
+    this.push(null);
+  };
+  onSourceError = (error) => {
+    this.destroy(error);
+  };
+  onSourceClose = () => {
+    if (!this.destroyed && !this.source.readableEnded) {
+      this.destroy(new Error("Connection lost or stream closed before all data was received."));
+    }
+  };
+  _read(_size) {
+    this.source.resume();
+  }
+  _destroy(error, callback) {
+    this.source?.removeListener("data", this.onSourceData);
+    this.source?.removeListener("end", this.onSourceEnd);
+    this.source?.removeListener("error", this.onSourceError);
+    this.source?.removeListener("close", this.onSourceClose);
+    this.source?.destroy();
+    callback(error);
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-type-check.js
+var isReadableStream = (stream) => typeof ReadableStream === "function" && (stream?.constructor?.name === ReadableStream.name || stream instanceof ReadableStream);
+var isBlob = (blob) => {
+  return typeof Blob === "function" && (blob?.constructor?.name === Blob.name || blob instanceof Blob);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/fromUtf8.browser.js
+var fromUtf82 = (input) => new TextEncoder().encode(input);
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/constants-for-browser.js
+var chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
+var alphabetByEncoding = Object.entries(chars).reduce((acc, [i, c]) => {
+  acc[c] = Number(i);
+  return acc;
+}, {});
+var alphabetByValue = chars.split("");
+var bitsPerLetter = 6;
+var bitsPerByte = 8;
+var maxLetterValue = 63;
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/toBase64.browser.js
+function toBase642(_input) {
+  let input;
+  if (typeof _input === "string") {
+    input = fromUtf82(_input);
+  } else {
+    input = _input;
+  }
+  const isArrayLike = typeof input === "object" && typeof input.length === "number";
+  const isUint8Array = typeof input === "object" && typeof input.byteOffset === "number" && typeof input.byteLength === "number";
+  if (!isArrayLike && !isUint8Array) {
+    throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
+  }
+  let str = "";
+  for (let i = 0; i < input.length; i += 3) {
+    let bits = 0;
+    let bitLength = 0;
+    for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {
+      bits |= input[j] << (limit - j - 1) * bitsPerByte;
+      bitLength += bitsPerByte;
+    }
+    const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
+    bits <<= bitClusterCount * bitsPerLetter - bitLength;
+    for (let k = 1; k <= bitClusterCount; k++) {
+      const offset = (bitClusterCount - k) * bitsPerLetter;
+      str += alphabetByValue[(bits & maxLetterValue << offset) >> offset];
+    }
+    str += "==".slice(0, 4 - bitClusterCount);
+  }
+  return str;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.browser.js
+var ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function() {
+};
+var ChecksumStream2 = class extends ReadableStreamRef {
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/createChecksumStream.browser.js
+var createChecksumStream = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) => {
+  if (!isReadableStream(source)) {
+    throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
+  }
+  const encoder = base64Encoder ?? toBase642;
+  if (typeof TransformStream !== "function") {
+    throw new Error("@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream.");
+  }
+  const transform = new TransformStream({
+    start() {
+    },
+    async transform(chunk, controller) {
+      checksum.update(chunk);
+      controller.enqueue(chunk);
+    },
+    async flush(controller) {
+      const digest = await checksum.digest();
+      const received = encoder(digest);
+      if (expectedChecksum !== received) {
+        const error = new Error(`Checksum mismatch: expected "${expectedChecksum}" but received "${received}" in response header "${checksumSourceLocation}".`);
+        controller.error(error);
+      } else {
+        controller.terminate();
+      }
+    }
+  });
+  source.pipeThrough(transform);
+  const readable = transform.readable;
+  Object.setPrototypeOf(readable, ChecksumStream2.prototype);
+  return readable;
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/createChecksumStream.js
+function createChecksumStream2(init) {
+  if (typeof ReadableStream === "function" && isReadableStream(init.source)) {
+    return createChecksumStream(init);
+  }
+  return new ChecksumStream(init);
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.js
+import { Readable as Readable2 } from "stream";
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/ByteArrayCollector.js
+var ByteArrayCollector = class {
+  allocByteArray;
+  byteLength = 0;
+  byteArrays = [];
+  constructor(allocByteArray) {
+    this.allocByteArray = allocByteArray;
+  }
+  push(byteArray) {
+    this.byteArrays.push(byteArray);
+    this.byteLength += byteArray.byteLength;
+  }
+  flush() {
+    if (this.byteArrays.length === 1) {
+      const bytes = this.byteArrays[0];
+      this.reset();
+      return bytes;
+    }
+    const aggregation = this.allocByteArray(this.byteLength);
+    let cursor = 0;
+    for (let i = 0; i < this.byteArrays.length; ++i) {
+      const bytes = this.byteArrays[i];
+      aggregation.set(bytes, cursor);
+      cursor += bytes.byteLength;
+    }
+    this.reset();
+    return aggregation;
+  }
+  reset() {
+    this.byteArrays = [];
+    this.byteLength = 0;
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.browser.js
+function createBufferedReadableStream(upstream, size, logger2) {
+  const reader = upstream.getReader();
+  let streamBufferingLoggedWarning = false;
+  let bytesSeen = 0;
+  const buffers = ["", new ByteArrayCollector((size2) => new Uint8Array(size2))];
+  let mode = -1;
+  const pull = async (controller) => {
+    const { value, done } = await reader.read();
+    const chunk = value;
+    if (done) {
+      if (mode !== -1) {
+        const remainder = flush(buffers, mode);
+        if (sizeOf(remainder) > 0) {
+          controller.enqueue(remainder);
+        }
+      }
+      controller.close();
+    } else {
+      const chunkMode = modeOf(chunk, false);
+      if (mode !== chunkMode) {
+        if (mode >= 0) {
+          controller.enqueue(flush(buffers, mode));
+        }
+        mode = chunkMode;
+      }
+      if (mode === -1) {
+        controller.enqueue(chunk);
+        return;
+      }
+      const chunkSize = sizeOf(chunk);
+      bytesSeen += chunkSize;
+      const bufferSize = sizeOf(buffers[mode]);
+      if (chunkSize >= size && bufferSize === 0) {
+        controller.enqueue(chunk);
+      } else {
+        const newSize = merge(buffers, mode, chunk);
+        if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
+          streamBufferingLoggedWarning = true;
+          logger2?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+        }
+        if (newSize >= size) {
+          controller.enqueue(flush(buffers, mode));
+        } else {
+          await pull(controller);
+        }
+      }
+    }
+  };
+  return new ReadableStream({
+    pull
+  });
+}
+function merge(buffers, mode, chunk) {
+  switch (mode) {
+    case 0:
+      buffers[0] += chunk;
+      return sizeOf(buffers[0]);
+    case 1:
+    case 2:
+      buffers[mode].push(chunk);
+      return sizeOf(buffers[mode]);
+  }
+}
+function flush(buffers, mode) {
+  switch (mode) {
+    case 0:
+      const s = buffers[0];
+      buffers[0] = "";
+      return s;
+    case 1:
+    case 2:
+      return buffers[mode].flush();
+  }
+  throw new Error(`@smithy/util-stream - invalid index ${mode} given to flush()`);
+}
+function sizeOf(chunk) {
+  return chunk?.byteLength ?? chunk?.length ?? 0;
+}
+function modeOf(chunk, allowBuffer = true) {
+  if (allowBuffer && typeof Buffer !== "undefined" && chunk instanceof Buffer) {
+    return 2;
+  }
+  if (chunk instanceof Uint8Array) {
+    return 1;
+  }
+  if (typeof chunk === "string") {
+    return 0;
+  }
+  return -1;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.js
+function createBufferedReadable(upstream, size, logger2) {
+  if (isReadableStream(upstream)) {
+    return createBufferedReadableStream(upstream, size, logger2);
+  }
+  const downstream = new Readable2({ read() {
+  } });
+  let streamBufferingLoggedWarning = false;
+  let bytesSeen = 0;
+  const buffers = [
+    "",
+    new ByteArrayCollector((size2) => new Uint8Array(size2)),
+    new ByteArrayCollector((size2) => Buffer.from(new Uint8Array(size2)))
+  ];
+  let mode = -1;
+  upstream.on("data", (chunk) => {
+    const chunkMode = modeOf(chunk, true);
+    if (mode !== chunkMode) {
+      if (mode >= 0) {
+        downstream.push(flush(buffers, mode));
+      }
+      mode = chunkMode;
+    }
+    if (mode === -1) {
+      downstream.push(chunk);
+      return;
+    }
+    const chunkSize = sizeOf(chunk);
+    bytesSeen += chunkSize;
+    const bufferSize = sizeOf(buffers[mode]);
+    if (chunkSize >= size && bufferSize === 0) {
+      downstream.push(chunk);
+    } else {
+      const newSize = merge(buffers, mode, chunk);
+      if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
+        streamBufferingLoggedWarning = true;
+        logger2?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
+      }
+      if (newSize >= size) {
+        downstream.push(flush(buffers, mode));
+      }
+    }
+  });
+  upstream.on("end", () => {
+    if (mode !== -1) {
+      const remainder = flush(buffers, mode);
+      if (sizeOf(remainder) > 0) {
+        downstream.push(remainder);
+      }
+    }
+    downstream.push(null);
+  });
+  return downstream;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.js
+import { Readable as Readable3 } from "stream";
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.browser.js
+var getAwsChunkedEncodingStream = (readableStream, options) => {
+  const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;
+  const checksumRequired = base64Encoder !== void 0 && bodyLengthChecker !== void 0 && checksumAlgorithmFn !== void 0 && checksumLocationName !== void 0 && streamHasher !== void 0;
+  const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readableStream) : void 0;
+  const reader = readableStream.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      const { value, done } = await reader.read();
+      if (done) {
+        controller.enqueue(`0\r
+`);
+        if (checksumRequired) {
+          const checksum = base64Encoder(await digest);
+          controller.enqueue(`${checksumLocationName}:${checksum}\r
+`);
+          controller.enqueue(`\r
+`);
+        }
+        controller.close();
+      } else {
+        controller.enqueue(`${(bodyLengthChecker(value) || 0).toString(16)}\r
+${value}\r
+`);
+      }
+    }
+  });
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.js
+function getAwsChunkedEncodingStream2(stream, options) {
+  const readable = stream;
+  const readableStream = stream;
+  if (isReadableStream(readableStream)) {
+    return getAwsChunkedEncodingStream(readableStream, options);
+  }
+  const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;
+  const checksumRequired = base64Encoder !== void 0 && checksumAlgorithmFn !== void 0 && checksumLocationName !== void 0 && streamHasher !== void 0;
+  const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readable) : void 0;
+  const awsChunkedEncodingStream = new Readable3({
+    read: () => {
+    }
+  });
+  readable.on("data", (data) => {
+    const length = bodyLengthChecker(data) || 0;
+    if (length === 0) {
+      return;
+    }
+    awsChunkedEncodingStream.push(`${length.toString(16)}\r
+`);
+    awsChunkedEncodingStream.push(data);
+    awsChunkedEncodingStream.push("\r\n");
+  });
+  readable.on("end", async () => {
+    awsChunkedEncodingStream.push(`0\r
+`);
+    if (checksumRequired) {
+      const checksum = base64Encoder(await digest);
+      awsChunkedEncodingStream.push(`${checksumLocationName}:${checksum}\r
+`);
+      awsChunkedEncodingStream.push(`\r
+`);
+    }
+    awsChunkedEncodingStream.push(null);
+  });
+  return awsChunkedEncodingStream;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/sdk-stream-mixin.js
+import { Readable as Readable4 } from "stream";
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUtf8.browser.js
+var toUtf82 = (input) => {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+    throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+  }
+  return new TextDecoder("utf-8").decode(input);
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.browser.js
+var streamCollector = async (stream) => {
+  if (isBlob(stream)) {
+    return collectBlob(stream);
+  }
+  return collectReadableStream(stream);
+};
+async function collectBlob(blob) {
+  return blob.arrayBuffer().then((ab) => new Uint8Array(ab));
+}
+async function collectReadableStream(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  let length = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      length += value.length;
+    }
+    if (done) {
+      break;
+    }
+  }
+  return concatBytes(chunks, length);
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/sdk-stream-mixin.browser.js
+var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
+var sdkStreamMixin = (stream) => {
+  if (!isBlobInstance(stream) && !isReadableStream(stream)) {
+    const name = stream?.__proto__?.constructor?.name || stream;
+    throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name}`);
+  }
+  let transformed = false;
+  const transformToByteArray = async () => {
+    if (transformed) {
+      throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+    }
+    transformed = true;
+    return await streamCollector(stream);
+  };
+  const blobToWebStream = (blob) => {
+    if (typeof blob.stream !== "function") {
+      throw new Error("Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.\nIf you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body");
+    }
+    return blob.stream();
+  };
+  return Object.assign(stream, {
+    transformToByteArray,
+    transformToString: async (encoding) => {
+      const buf = await transformToByteArray();
+      if (encoding === "base64") {
+        return toBase642(buf);
+      } else if (encoding === "hex") {
+        return toHex(buf);
+      } else if (encoding === void 0 || encoding === "utf8" || encoding === "utf-8") {
+        return toUtf82(buf);
+      } else if (typeof TextDecoder === "function") {
+        return new TextDecoder(encoding).decode(buf);
+      } else {
+        throw new Error("TextDecoder is not available, please make sure polyfill is provided.");
+      }
+    },
+    transformToWebStream: () => {
+      if (transformed) {
+        throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+      }
+      transformed = true;
+      if (isBlobInstance(stream)) {
+        return blobToWebStream(stream);
+      } else if (isReadableStream(stream)) {
+        return stream;
+      } else {
+        throw new Error(`Cannot transform payload to web stream, got ${stream}`);
+      }
+    }
+  });
+};
+var isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.js
+import { Writable } from "stream";
+var streamCollector2 = (stream) => {
+  if (isBlob(stream)) {
+    return collectBlob(stream);
+  }
+  if (isReadableStream(stream)) {
+    return collectReadableStream(stream);
+  }
+  return new Promise((resolve, reject) => {
+    const collector = new Collector();
+    const nodeStream = stream;
+    nodeStream.pipe(collector);
+    nodeStream.on("error", (err) => {
+      collector.end();
+      reject(err);
+    });
+    collector.on("error", reject);
+    collector.on("finish", function() {
+      const bytes = concatBytes(this.bufferedBytes);
+      resolve(bytes);
+    });
+  });
+};
+var Collector = class extends Writable {
+  bufferedBytes = [];
+  _write(chunk, encoding, callback) {
+    this.bufferedBytes.push(chunk);
+    callback();
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/sdk-stream-mixin.js
+var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2 = "The stream has already been transformed.";
+var sdkStreamMixin2 = (stream) => {
+  if (!(stream instanceof Readable4)) {
+    try {
+      return sdkStreamMixin(stream);
+    } catch (ignored) {
+      const name = stream?.__proto__?.constructor?.name || stream;
+      throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
+    }
+  }
+  let transformed = false;
+  const transformToByteArray = async () => {
+    if (transformed) {
+      throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2);
+    }
+    transformed = true;
+    return await streamCollector2(stream);
+  };
+  return Object.assign(stream, {
+    transformToByteArray,
+    transformToString: async (encoding) => {
+      const buf = await transformToByteArray();
+      if (encoding === void 0 || Buffer.isEncoding(encoding)) {
+        return fromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding);
+      } else {
+        const decoder = new TextDecoder(encoding);
+        return decoder.decode(buf);
+      }
+    },
+    transformToWebStream: () => {
+      if (transformed) {
+        throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2);
+      }
+      if (stream.readableFlowing !== null) {
+        throw new Error("The stream has been consumed by other callbacks.");
+      }
+      if (typeof Readable4.toWeb !== "function") {
+        throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
+      }
+      transformed = true;
+      return Readable4.toWeb(stream);
+    }
+  });
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/index.js
+var Uint8ArrayBlobAdapter = class extends bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+};
+var _getRandomValues = getRandomValues;
+var v4 = bindV4(_getRandomValues);
+var generateIdempotencyToken = v4;
+
+export {
+  EndpointURLScheme,
+  AlgorithmId,
+  SMITHY_CONTEXT_KEY,
+  IniSectionType,
+  getSmithyContext,
+  hasOwn,
+  HttpRequest,
+  HttpResponse,
+  isValidHostLabel,
+  isValidHostname,
+  normalizeProvider,
+  parseUrl,
+  toEndpointV1,
+  deref,
+  getSchemaSerdePlugin,
+  translateTraits,
+  NormalizedSchema,
+  TypeRegistry,
+  isArrayBuffer,
+  fromBase64,
+  fromUtf8,
+  toBase64,
+  toUtf8,
+  dateToUtcString,
+  parseRfc3339DateTime,
+  parseRfc3339DateTimeWithOffset,
+  parseRfc7231DateTime,
+  parseEpochTimestamp,
+  LazyJsonString,
+  quoteHeader,
+  _parseEpochTimestamp,
+  _parseRfc3339DateTimeWithOffset,
+  _parseRfc7231DateTime,
+  splitEvery,
+  splitHeader,
+  NumericValue,
+  fromHex,
+  toHex,
+  calculateBodyLength,
+  toUint8Array,
+  createChecksumStream2 as createChecksumStream,
+  createBufferedReadable,
+  getAwsChunkedEncodingStream2 as getAwsChunkedEncodingStream,
+  streamCollector2 as streamCollector,
+  sdkStreamMixin2 as sdkStreamMixin,
+  Uint8ArrayBlobAdapter,
+  v4,
+  generateIdempotencyToken
+};