@junando/core 0.16.1 → 0.16.3

package/dist/serde-Cq0wappq.js

@@ -0,0 +1,2179 @@
+import { n as __esmMin, r as __exportAll } from "./rolldown-runtime-BMI-E3GI.js";
+import { t as require_dist_cjs } from "./dist-cjs-CBX4z-Yb.js";
+import { createHash, createHmac, getRandomValues } from "node:crypto";
+import { PassThrough, Readable, Writable } from "node:stream";
+import { ReadStream, fstatSync, lstatSync } from "node:fs";
+//#region ../../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;
+var init_is_array_buffer = __esmMin((() => {
+	isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-buffer-from/buffer-from.js
+var fromArrayBuffer, fromString;
+var init_buffer_from = __esmMin((() => {
+	init_is_array_buffer();
+	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);
+	};
+	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);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/fromBase64.js
+var BASE64_REGEX, fromBase64;
+var init_fromBase64 = __esmMin((() => {
+	init_buffer_from();
+	BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
+	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);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/fromUtf8.js
+var fromUtf8$1;
+var init_fromUtf8 = __esmMin((() => {
+	init_buffer_from();
+	fromUtf8$1 = (input) => {
+		const buf = fromString(input, "utf8");
+		return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/toBase64.js
+var toBase64$1;
+var init_toBase64 = __esmMin((() => {
+	init_buffer_from();
+	init_fromUtf8();
+	toBase64$1 = (_input) => {
+		let input;
+		if (typeof _input === "string") input = fromUtf8$1(_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");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/blob/Uint8ArrayBlobAdapter.js
+function bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
+	return class Uint8ArrayBlobAdapter extends Uint8Array {
+		static fromString(source, encoding = "utf-8") {
+			if (typeof source === "string") {
+				if (encoding === "base64") return Uint8ArrayBlobAdapter.mutate(fromBase64(source));
+				return Uint8ArrayBlobAdapter.mutate(fromUtf8(source));
+			}
+			throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
+		}
+		static mutate(source) {
+			Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);
+			return source;
+		}
+		transformToString(encoding = "utf-8") {
+			if (encoding === "base64") return toBase64(this);
+			return toUtf8(this);
+		}
+	};
+}
+var init_Uint8ArrayBlobAdapter = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUtf8.js
+var toUtf8$1;
+var init_toUtf8 = __esmMin((() => {
+	init_buffer_from();
+	toUtf8$1 = (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");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/uuid/v4.js
+function bindV4(getRandomValues) {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return () => crypto.randomUUID();
+	return () => {
+		const rnds = /* @__PURE__ */ new Uint8Array(16);
+		getRandomValues(rnds);
+		rnds[6] = rnds[6] & 15 | 64;
+		rnds[8] = rnds[8] & 63 | 128;
+		return decimalToHex[rnds[0]] + decimalToHex[rnds[1]] + decimalToHex[rnds[2]] + decimalToHex[rnds[3]] + "-" + decimalToHex[rnds[4]] + decimalToHex[rnds[5]] + "-" + decimalToHex[rnds[6]] + decimalToHex[rnds[7]] + "-" + decimalToHex[rnds[8]] + decimalToHex[rnds[9]] + "-" + decimalToHex[rnds[10]] + decimalToHex[rnds[11]] + decimalToHex[rnds[12]] + decimalToHex[rnds[13]] + decimalToHex[rnds[14]] + decimalToHex[rnds[15]];
+	};
+}
+var decimalToHex;
+var init_v4 = __esmMin((() => {
+	decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/copyDocumentWithTransform.js
+var copyDocumentWithTransform;
+var init_copyDocumentWithTransform = __esmMin((() => {
+	copyDocumentWithTransform = (source, _schemaRef, _transform = (_) => _) => source;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/getSmithyContext.js
+var import_dist_cjs, getSmithyContext;
+var init_getSmithyContext = __esmMin((() => {
+	import_dist_cjs = require_dist_cjs();
+	getSmithyContext = (context) => context[import_dist_cjs.SMITHY_CONTEXT_KEY] || (context[import_dist_cjs.SMITHY_CONTEXT_KEY] = {});
+}));
+//#endregion
+//#region ../../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);
+}
+var init_hasOwn = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/httpRequest.js
+function cloneQuery(query) {
+	return Object.keys(query).reduce((carry, paramName) => {
+		const param = query[paramName];
+		return {
+			...carry,
+			[paramName]: Array.isArray(param) ? [...param] : param
+		};
+	}, {});
+}
+var HttpRequest;
+var init_httpRequest = __esmMin((() => {
+	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);
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/httpResponse.js
+var HttpResponse;
+var init_httpResponse = __esmMin((() => {
+	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";
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/isValidHostname.js
+function isValidHostname(hostname) {
+	return /^[a-z0-9][a-z0-9.-]*[a-z0-9]$/.test(hostname);
+}
+var init_isValidHostname = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/normalizeProvider.js
+var normalizeProvider;
+var init_normalizeProvider = __esmMin((() => {
+	normalizeProvider = (input) => {
+		if (typeof input === "function") return input;
+		const promisified = Promise.resolve(input);
+		return () => promisified;
+	};
+}));
+//#endregion
+//#region ../../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;
+}
+var init_parseQueryString = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/parseUrl.js
+var parseUrl;
+var init_parseUrl = __esmMin((() => {
+	init_parseQueryString();
+	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
+		};
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/toEndpointV1.js
+var toEndpointV1;
+var init_toEndpointV1 = __esmMin((() => {
+	init_hasOwn();
+	init_parseUrl();
+	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);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/transport/index.js
+var init_transport = __esmMin((() => {
+	init_getSmithyContext();
+	init_hasOwn();
+	init_httpRequest();
+	init_httpResponse();
+	init_isValidHostname();
+	init_normalizeProvider();
+	init_parseQueryString();
+	init_parseUrl();
+	init_toEndpointV1();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/parse-utils.js
+var parseBoolean, expectBoolean, expectNumber, MAX_FLOAT, expectFloat32, expectLong, expectInt, expectInt32, expectShort, expectByte, expectSizedInt, castInt, expectNonNull, expectObject, expectString, expectUnion, strictParseDouble, strictParseFloat, strictParseFloat32, NUMBER_REGEX, parseNumber, limitedParseDouble, handleFloat, limitedParseFloat, limitedParseFloat32, parseFloatString, strictParseLong, strictParseInt, strictParseInt32, strictParseShort, strictParseByte, stackTraceWarning, logger;
+var init_parse_utils = __esmMin((() => {
+	init_transport();
+	parseBoolean = (value) => {
+		switch (value) {
+			case "true": return true;
+			case "false": return false;
+			default: throw new Error(`Unable to parse boolean value "${value}"`);
+		}
+	};
+	expectBoolean = (value) => {
+		if (value === null || value === void 0) return;
+		if (typeof value === "number") {
+			if (value === 0 || value === 1) logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
+			if (value === 0) return false;
+			if (value === 1) return true;
+		}
+		if (typeof value === "string") {
+			const lower = value.toLowerCase();
+			if (lower === "false" || lower === "true") logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
+			if (lower === "false") return false;
+			if (lower === "true") return true;
+		}
+		if (typeof value === "boolean") return value;
+		throw new TypeError(`Expected boolean, got ${typeof value}: ${value}`);
+	};
+	expectNumber = (value) => {
+		if (value === null || value === void 0) return;
+		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}`);
+	};
+	MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
+	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;
+	};
+	expectLong = (value) => {
+		if (value === null || value === void 0) return;
+		if (Number.isInteger(value) && !Number.isNaN(value)) return value;
+		throw new TypeError(`Expected integer, got ${typeof value}: ${value}`);
+	};
+	expectInt = expectLong;
+	expectInt32 = (value) => expectSizedInt(value, 32);
+	expectShort = (value) => expectSizedInt(value, 16);
+	expectByte = (value) => expectSizedInt(value, 8);
+	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;
+	};
+	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];
+		}
+	};
+	expectNonNull = (value, location) => {
+		if (value === null || value === void 0) {
+			if (location) throw new TypeError(`Expected a non-null value for ${location}`);
+			throw new TypeError("Expected a non-null value");
+		}
+		return value;
+	};
+	expectObject = (value) => {
+		if (value === null || value === void 0) return;
+		if (typeof value === "object" && !Array.isArray(value)) return value;
+		throw new TypeError(`Expected object, got ${Array.isArray(value) ? "array" : typeof value}: ${value}`);
+	};
+	expectString = (value) => {
+		if (value === null || value === void 0) return;
+		if (typeof value === "string") return value;
+		if ([
+			"boolean",
+			"number",
+			"bigint"
+		].includes(typeof value)) {
+			logger.warn(stackTraceWarning(`Expected string, got ${typeof value}: ${value}`));
+			return String(value);
+		}
+		throw new TypeError(`Expected string, got ${typeof value}: ${value}`);
+	};
+	expectUnion = (value) => {
+		if (value === null || value === void 0) return;
+		const asObject = expectObject(value);
+		const setKeys = [];
+		for (const k in asObject) {
+			if (!hasOwn(asObject, k)) continue;
+			if (asObject[k] != null) setKeys.push(k);
+		}
+		if (setKeys.length === 0) throw new TypeError(`Unions must have exactly one non-null member. None were found.`);
+		if (setKeys.length > 1) throw new TypeError(`Unions must have exactly one non-null member. Keys ${setKeys} were not null.`);
+		return asObject;
+	};
+	strictParseDouble = (value) => {
+		if (typeof value == "string") return expectNumber(parseNumber(value));
+		return expectNumber(value);
+	};
+	strictParseFloat = strictParseDouble;
+	strictParseFloat32 = (value) => {
+		if (typeof value == "string") return expectFloat32(parseNumber(value));
+		return expectFloat32(value);
+	};
+	NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g;
+	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);
+	};
+	limitedParseDouble = (value) => {
+		if (typeof value == "string") return parseFloatString(value);
+		return expectNumber(value);
+	};
+	handleFloat = limitedParseDouble;
+	limitedParseFloat = limitedParseDouble;
+	limitedParseFloat32 = (value) => {
+		if (typeof value == "string") return parseFloatString(value);
+		return expectFloat32(value);
+	};
+	parseFloatString = (value) => {
+		switch (value) {
+			case "NaN": return NaN;
+			case "Infinity": return Infinity;
+			case "-Infinity": return -Infinity;
+			default: throw new Error(`Unable to parse float value: ${value}`);
+		}
+	};
+	strictParseLong = (value) => {
+		if (typeof value === "string") return expectLong(parseNumber(value));
+		return expectLong(value);
+	};
+	strictParseInt = strictParseLong;
+	strictParseInt32 = (value) => {
+		if (typeof value === "string") return expectInt32(parseNumber(value));
+		return expectInt32(value);
+	};
+	strictParseShort = (value) => {
+		if (typeof value === "string") return expectShort(parseNumber(value));
+		return expectShort(value);
+	};
+	strictParseByte = (value) => {
+		if (typeof value === "string") return expectByte(parseNumber(value));
+		return expectByte(value);
+	};
+	stackTraceWarning = (message) => {
+		return String(new TypeError(message).stack || message).split("\n").slice(0, 5).filter((s) => !s.includes("stackTraceWarning")).join("\n");
+	};
+	logger = { warn: console.warn };
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/date-utils.js
+function dateToUtcString(date) {
+	const year = date.getUTCFullYear();
+	const month = date.getUTCMonth();
+	const dayOfWeek = date.getUTCDay();
+	const dayOfMonthInt = date.getUTCDate();
+	const hoursInt = date.getUTCHours();
+	const minutesInt = date.getUTCMinutes();
+	const secondsInt = date.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]} ${year} ${hoursString}:${minutesString}:${secondsString} GMT`;
+}
+var DAYS, MONTHS, RFC3339, parseRfc3339DateTime, RFC3339_WITH_OFFSET$1, parseRfc3339DateTimeWithOffset, IMF_FIXDATE$1, RFC_850_DATE$1, ASC_TIME$1, parseRfc7231DateTime, parseEpochTimestamp, buildDate, parseTwoDigitYear, FIFTY_YEARS_IN_MILLIS, adjustRfc850Year, parseMonthByShortName, DAYS_IN_MONTH, validateDayOfMonth, isLeapYear, parseDateValue, parseMilliseconds, parseOffsetToMilliseconds, stripLeadingZeroes;
+var init_date_utils = __esmMin((() => {
+	init_parse_utils();
+	DAYS = [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	];
+	MONTHS = [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	];
+	RFC3339 = /* @__PURE__ */ new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/);
+	parseRfc3339DateTime = (value) => {
+		if (value === null || value === void 0) return;
+		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 year = strictParseShort(stripLeadingZeroes(yearStr));
+		const month = parseDateValue(monthStr, "month", 1, 12);
+		const day = parseDateValue(dayStr, "day", 1, 31);
+		return buildDate(year, month, day, {
+			hours,
+			minutes,
+			seconds,
+			fractionalMilliseconds
+		});
+	};
+	RFC3339_WITH_OFFSET$1 = /* @__PURE__ */ new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}:\d{2})|[zZ])$/);
+	parseRfc3339DateTimeWithOffset = (value) => {
+		if (value === null || value === void 0) return;
+		if (typeof value !== "string") throw new TypeError("RFC-3339 date-times must be expressed as strings");
+		const match = RFC3339_WITH_OFFSET$1.exec(value);
+		if (!match) throw new TypeError("Invalid RFC-3339 date-time value");
+		const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, offsetStr] = match;
+		const year = strictParseShort(stripLeadingZeroes(yearStr));
+		const month = parseDateValue(monthStr, "month", 1, 12);
+		const day = parseDateValue(dayStr, "day", 1, 31);
+		const date = buildDate(year, month, day, {
+			hours,
+			minutes,
+			seconds,
+			fractionalMilliseconds
+		});
+		if (offsetStr.toUpperCase() != "Z") date.setTime(date.getTime() - parseOffsetToMilliseconds(offsetStr));
+		return date;
+	};
+	IMF_FIXDATE$1 = /* @__PURE__ */ 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$/);
+	RFC_850_DATE$1 = /* @__PURE__ */ 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$/);
+	ASC_TIME$1 = /* @__PURE__ */ 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})$/);
+	parseRfc7231DateTime = (value) => {
+		if (value === null || value === void 0) return;
+		if (typeof value !== "string") throw new TypeError("RFC-7231 date-times must be expressed as strings");
+		let match = IMF_FIXDATE$1.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$1.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$1.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");
+	};
+	parseEpochTimestamp = (value) => {
+		if (value === null || value === void 0) return;
+		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));
+	};
+	buildDate = (year, month, day, time) => {
+		const adjustedMonth = month - 1;
+		validateDayOfMonth(year, adjustedMonth, day);
+		return new Date(Date.UTC(year, adjustedMonth, day, parseDateValue(time.hours, "hour", 0, 23), parseDateValue(time.minutes, "minute", 0, 59), parseDateValue(time.seconds, "seconds", 0, 60), parseMilliseconds(time.fractionalMilliseconds)));
+	};
+	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;
+	};
+	FIFTY_YEARS_IN_MILLIS = 15768e8;
+	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;
+	};
+	parseMonthByShortName = (value) => {
+		const monthIdx = MONTHS.indexOf(value);
+		if (monthIdx < 0) throw new TypeError(`Invalid month: ${value}`);
+		return monthIdx + 1;
+	};
+	DAYS_IN_MONTH = [
+		31,
+		28,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	];
+	validateDayOfMonth = (year, month, day) => {
+		let maxDays = DAYS_IN_MONTH[month];
+		if (month === 1 && isLeapYear(year)) maxDays = 29;
+		if (day > maxDays) throw new TypeError(`Invalid day for ${MONTHS[month]} in ${year}: ${day}`);
+	};
+	isLeapYear = (year) => {
+		return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+	};
+	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;
+	};
+	parseMilliseconds = (value) => {
+		if (value === null || value === void 0) return 0;
+		return strictParseFloat32("0." + value) * 1e3;
+	};
+	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;
+	};
+	stripLeadingZeroes = (value) => {
+		let idx = 0;
+		while (idx < value.length - 1 && value.charAt(idx) === "0") idx++;
+		if (idx === 0) return value;
+		return value.slice(idx);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/lazy-json.js
+var LazyJsonString;
+var init_lazy_json = __esmMin((() => {
+	LazyJsonString = function LazyJsonString(val) {
+		return Object.assign(new String(val), {
+			deserializeJSON() {
+				return JSON.parse(String(val));
+			},
+			toString() {
+				return String(val);
+			},
+			toJSON() {
+				return String(val);
+			}
+		});
+	};
+	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;
+}));
+//#endregion
+//#region ../../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;
+}
+var init_quote_header = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/schema-serde-lib/schema-date-utils.js
+function range(v, min, max) {
+	const _v = Number(v);
+	if (_v < min || _v > max) throw new Error(`Value ${_v} out of range [${min}, ${max}]`);
+}
+var ddd, mmm, time, date, year, RFC3339_WITH_OFFSET, IMF_FIXDATE, RFC_850_DATE, ASC_TIME, months, _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime;
+var init_schema_date_utils = __esmMin((() => {
+	ddd = `(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)(?:[ne|u?r]?s?day)?`;
+	mmm = `(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)`;
+	time = `(\\d?\\d):(\\d{2}):(\\d{2})(?:\\.(\\d+))?`;
+	date = `(\\d?\\d)`;
+	year = `(\\d{4})`;
+	RFC3339_WITH_OFFSET = /* @__PURE__ */ new RegExp(/^(\d{4})-(\d\d)-(\d\d)[tT](\d\d):(\d\d):(\d\d)(\.(\d+))?(([-+]\d\d:\d\d)|[zZ])$/);
+	IMF_FIXDATE = new RegExp(`^${ddd}, ${date} ${mmm} ${year} ${time} GMT$`);
+	RFC_850_DATE = new RegExp(`^${ddd}, ${date}-${mmm}-(\\d\\d) ${time} GMT$`);
+	ASC_TIME = new RegExp(`^${ddd} ${mmm} ( [1-9]|\\d\\d) ${time} ${year}$`);
+	months = [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	];
+	_parseEpochTimestamp = (value) => {
+		if (value == null) return;
+		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));
+	};
+	_parseRfc3339DateTimeWithOffset = (value) => {
+		if (value == null) return;
+		if (typeof value !== "string") throw new TypeError("RFC3339 timestamps must be strings");
+		const matches = RFC3339_WITH_OFFSET.exec(value);
+		if (!matches) throw new TypeError(`Invalid RFC3339 timestamp format ${value}`);
+		const [, yearStr, monthStr, dayStr, hours, minutes, seconds, , ms, offsetStr] = matches;
+		range(monthStr, 1, 12);
+		range(dayStr, 1, 31);
+		range(hours, 0, 23);
+		range(minutes, 0, 59);
+		range(seconds, 0, 60);
+		const date = 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));
+		date.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;
+			date.setTime(date.getTime() + scalar * (Number(offsetH) * 60 * 60 * 1e3 + Number(offsetM) * 60 * 1e3));
+		}
+		return date;
+	};
+	_parseRfc7231DateTime = (value) => {
+		if (value == null) return;
+		if (typeof value !== "string") throw new TypeError("RFC7231 timestamps must be strings.");
+		let day;
+		let month;
+		let year;
+		let hour;
+		let minute;
+		let second;
+		let fraction;
+		let matches;
+		if (matches = IMF_FIXDATE.exec(value)) [, day, month, year, hour, minute, second, fraction] = matches;
+		else if (matches = RFC_850_DATE.exec(value)) {
+			[, day, month, year, hour, minute, second, fraction] = matches;
+			year = (Number(year) + 1900).toString();
+		} else if (matches = ASC_TIME.exec(value)) [, month, day, hour, minute, second, fraction, year] = matches;
+		if (year && second) {
+			const timestamp = Date.UTC(Number(year), 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 date = new Date(timestamp);
+			date.setUTCFullYear(Number(year));
+			return date;
+		}
+		throw new TypeError(`Invalid RFC7231 date-time value ${value}.`);
+	};
+}));
+//#endregion
+//#region ../../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;
+}
+var init_split_every = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/split-header.js
+var splitHeader;
+var init_split_header = __esmMin((() => {
+	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;
+				}
+			}
+			prevChar = char;
+		}
+		values.push(value.slice(anchor));
+		return values.map((v) => {
+			v = v.trim();
+			const z = v.length;
+			if (z < 2) return v;
+			if (v[0] === `"` && v[z - 1] === `"`) v = v.slice(1, z - 1);
+			return v.replace(/\\"/g, "\"");
+		});
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js
+function nv(input) {
+	return new NumericValue(String(input), "bigDecimal");
+}
+var format, NumericValue;
+var init_NumericValue = __esmMin((() => {
+	format = /^-?((0|[1-9]\d*)(\.\d+)?|\.\d+)([eE][+-]?\d+)?$/;
+	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);
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-hex-encoding/hex-encoding.js
+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;
+}
+var SHORT_TO_HEX, HEX_TO_SHORT;
+var init_hex_encoding = __esmMin((() => {
+	SHORT_TO_HEX = {};
+	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;
+	}
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-body-length/calculateBodyLength.js
+var calculateBodyLength;
+var init_calculateBodyLength = __esmMin((() => {
+	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}`);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUint8Array.js
+var toUint8Array;
+var init_toUint8Array = __esmMin((() => {
+	init_fromUtf8();
+	toUint8Array = (data) => {
+		if (data instanceof Uint8Array) return data;
+		if (typeof data === "string") return fromUtf8$1(data);
+		if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+		return new Uint8Array(data);
+	};
+}));
+//#endregion
+//#region ../../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;
+}
+var init_concatBytes = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/middleware-serde/deserializerMiddleware.js
+var deserializerMiddleware, findHeader;
+var init_deserializerMiddleware = __esmMin((() => {
+	init_transport();
+	deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
+		const { response } = await next(args);
+		try {
+			return {
+				response,
+				output: await deserializer(response, options)
+			};
+		} 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 = {} } = response;
+						const headerEntries = Object.entries(headers);
+						error.$metadata = {
+							httpStatusCode: response.statusCode,
+							requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
+							extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
+							cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
+						};
+					}
+				} catch (ignored) {}
+			}
+			throw error;
+		}
+	};
+	findHeader = (pattern, headers) => {
+		return (headers.find(([k]) => {
+			return k.match(pattern);
+		}) || [void 0, void 0])[1];
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/deref.js
+var deref;
+var init_deref = __esmMin((() => {
+	deref = (schemaRef) => {
+		if (typeof schemaRef === "function") return schemaRef();
+		return schemaRef;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/schemas/translateTraits.js
+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;
+}
+var traitsCache;
+var init_translateTraits = __esmMin((() => {
+	traitsCache = [];
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js
+function member(memberSchema, memberName) {
+	if (memberSchema instanceof NormalizedSchema) return Object.assign(memberSchema, {
+		memberName,
+		_isMemberSchema: true
+	});
+	return new NormalizedSchema(memberSchema, memberName);
+}
+var anno, simpleSchemaCacheN, simpleSchemaCacheS, NormalizedSchema, isMemberSchema, isStaticSchema;
+var init_NormalizedSchema = __esmMin((() => {
+	init_deref();
+	init_translateTraits();
+	anno = {
+		it: Symbol.for("@smithy/nor-struct-it"),
+		ns: Symbol.for("@smithy/ns")
+	};
+	simpleSchemaCacheN = [];
+	simpleSchemaCacheS = {};
+	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) return lhs.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 [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)}.`);
+			}
+			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;
+			return !withNamespace && name && name.includes("#") ? 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();
+			return member([isDoc ? 15 : schema[4] ?? 0, 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;
+		}
+	};
+	isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
+	isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js
+var TypeRegistry;
+var init_TypeRegistry = __esmMin((() => {
+	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 [shapeId, schema] of this.schemas.entries()) if (shapeId.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);
+			return TypeRegistry.for($error[1]).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;
+			}
+		}
+		find(predicate) {
+			for (const schema of this.schemas.values()) if (predicate(schema)) return schema;
+		}
+		clear() {
+			this.schemas.clear();
+			this.exceptions.clear();
+		}
+		normalizeShapeId(shapeId) {
+			if (shapeId.includes("#")) return shapeId;
+			return this.namespace + "#" + shapeId;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/schema/index.js
+var init_schema = __esmMin((() => {
+	init_deref();
+	init_transport();
+	init_NormalizedSchema();
+	init_translateTraits();
+	init_TypeRegistry();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/endpoints/index.js
+var init_endpoints = __esmMin((() => {
+	init_transport();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/middleware-serde/serializerMiddleware.js
+var serializerMiddleware;
+var init_serializerMiddleware = __esmMin((() => {
+	init_endpoints();
+	serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
+		const endpointConfig = options;
+		const endpoint = context.endpointV2 ? async () => toEndpointV1(context.endpointV2) : endpointConfig.endpoint;
+		if (!endpoint) throw new Error("No valid endpoint provider available.");
+		const request = await serializer(args.input, {
+			...options,
+			endpoint
+		});
+		return next({
+			...args,
+			request
+		});
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/middleware-serde/serdePlugin.js
+function getSerdePlugin(config, serializer, deserializer) {
+	return { applyToStack: (commandStack) => {
+		commandStack.add(deserializerMiddleware(config, deserializer), deserializerMiddlewareOption);
+		commandStack.add(serializerMiddleware(config, serializer), serializerMiddlewareOption);
+	} };
+}
+var deserializerMiddlewareOption, serializerMiddlewareOption;
+var init_serdePlugin = __esmMin((() => {
+	init_deserializerMiddleware();
+	init_serializerMiddleware();
+	deserializerMiddlewareOption = {
+		name: "deserializerMiddleware",
+		step: "deserialize",
+		tags: ["DESERIALIZER"],
+		override: true
+	};
+	serializerMiddlewareOption = {
+		name: "serializerMiddleware",
+		step: "serialize",
+		tags: ["SERIALIZER"],
+		override: true
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/hash-node/hash-node.js
+function castSourceData(toCast, encoding) {
+	if (Buffer.isBuffer(toCast)) return toCast;
+	if (typeof toCast === "string") return fromString(toCast, encoding);
+	if (ArrayBuffer.isView(toCast)) return fromArrayBuffer(toCast.buffer, toCast.byteOffset, toCast.byteLength);
+	return fromArrayBuffer(toCast);
+}
+var Hash;
+var init_hash_node = __esmMin((() => {
+	init_buffer_from();
+	init_toUint8Array();
+	Hash = class {
+		algorithmIdentifier;
+		secret;
+		hash;
+		constructor(algorithmIdentifier, secret) {
+			this.algorithmIdentifier = algorithmIdentifier;
+			this.secret = secret;
+			this.reset();
+		}
+		update(toHash, encoding) {
+			this.hash.update(toUint8Array(castSourceData(toHash, encoding)));
+		}
+		digest() {
+			return Promise.resolve(this.hash.digest());
+		}
+		reset() {
+			this.hash = this.secret ? createHmac(this.algorithmIdentifier, castSourceData(this.secret)) : createHash(this.algorithmIdentifier);
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.js
+var ChecksumStream$1;
+var init_ChecksumStream = __esmMin((() => {
+	init_toBase64();
+	ChecksumStream$1 = 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$1;
+			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(/* @__PURE__ */ 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(/* @__PURE__ */ 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);
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-type-check.js
+var isReadableStream, isBlob;
+var init_stream_type_check = __esmMin((() => {
+	isReadableStream = (stream) => typeof ReadableStream === "function" && (stream?.constructor?.name === ReadableStream.name || stream instanceof ReadableStream);
+	isBlob = (blob) => {
+		return typeof Blob === "function" && (blob?.constructor?.name === Blob.name || blob instanceof Blob);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/fromUtf8.browser.js
+var fromUtf8;
+var init_fromUtf8_browser = __esmMin((() => {
+	fromUtf8 = (input) => new TextEncoder().encode(input);
+})), chars, alphabetByValue;
+var init_constants_for_browser = __esmMin((() => {
+	chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
+	Object.entries(chars).reduce((acc, [i, c]) => {
+		acc[c] = Number(i);
+		return acc;
+	}, {});
+	alphabetByValue = chars.split("");
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-base64/toBase64.browser.js
+function toBase64(_input) {
+	let input;
+	if (typeof _input === "string") input = fromUtf8(_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) * 8;
+			bitLength += 8;
+		}
+		const bitClusterCount = Math.ceil(bitLength / 6);
+		bits <<= bitClusterCount * 6 - bitLength;
+		for (let k = 1; k <= bitClusterCount; k++) {
+			const offset = (bitClusterCount - k) * 6;
+			str += alphabetByValue[(bits & 63 << offset) >> offset];
+		}
+		str += "==".slice(0, 4 - bitClusterCount);
+	}
+	return str;
+}
+var init_toBase64_browser = __esmMin((() => {
+	init_fromUtf8_browser();
+	init_constants_for_browser();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/ChecksumStream.browser.js
+var ReadableStreamRef, ChecksumStream;
+var init_ChecksumStream_browser = __esmMin((() => {
+	ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function() {};
+	ChecksumStream = class extends ReadableStreamRef {};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/createChecksumStream.browser.js
+var createChecksumStream$1;
+var init_createChecksumStream_browser = __esmMin((() => {
+	init_toBase64_browser();
+	init_stream_type_check();
+	init_ChecksumStream_browser();
+	createChecksumStream$1 = ({ 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 ?? toBase64;
+		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 = /* @__PURE__ */ 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, ChecksumStream.prototype);
+		return readable;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/checksum/createChecksumStream.js
+function createChecksumStream(init) {
+	if (typeof ReadableStream === "function" && isReadableStream(init.source)) return createChecksumStream$1(init);
+	return new ChecksumStream$1(init);
+}
+var init_createChecksumStream = __esmMin((() => {
+	init_stream_type_check();
+	init_ChecksumStream();
+	init_createChecksumStream_browser();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/ByteArrayCollector.js
+var ByteArrayCollector;
+var init_ByteArrayCollector = __esmMin((() => {
+	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;
+		}
+	};
+}));
+//#endregion
+//#region ../../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, logger) {
+	const reader = upstream.getReader();
+	let streamBufferingLoggedWarning = false;
+	let bytesSeen = 0;
+	const buffers = ["", new ByteArrayCollector((size) => new Uint8Array(size))];
+	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;
+					logger?.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;
+}
+var init_createBufferedReadable_browser = __esmMin((() => {
+	init_ByteArrayCollector();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/createBufferedReadable.js
+function createBufferedReadable(upstream, size, logger) {
+	if (isReadableStream(upstream)) return createBufferedReadableStream(upstream, size, logger);
+	const downstream = new Readable({ read() {} });
+	let streamBufferingLoggedWarning = false;
+	let bytesSeen = 0;
+	const buffers = [
+		"",
+		new ByteArrayCollector((size) => new Uint8Array(size)),
+		new ByteArrayCollector((size) => Buffer.from(new Uint8Array(size)))
+	];
+	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;
+				logger?.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;
+}
+var init_createBufferedReadable = __esmMin((() => {
+	init_ByteArrayCollector();
+	init_createBufferedReadable_browser();
+	init_stream_type_check();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.browser.js
+var getAwsChunkedEncodingStream$1;
+var init_getAwsChunkedEncodingStream_browser = __esmMin((() => {
+	getAwsChunkedEncodingStream$1 = (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\n`);
+				if (checksumRequired) {
+					const checksum = base64Encoder(await digest);
+					controller.enqueue(`${checksumLocationName}:${checksum}\r\n`);
+					controller.enqueue(`\r\n`);
+				}
+				controller.close();
+			} else controller.enqueue(`${(bodyLengthChecker(value) || 0).toString(16)}\r\n${value}\r\n`);
+		} });
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.js
+function getAwsChunkedEncodingStream(stream, options) {
+	const readable = stream;
+	const readableStream = stream;
+	if (isReadableStream(readableStream)) return getAwsChunkedEncodingStream$1(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 Readable({ read: () => {} });
+	readable.on("data", (data) => {
+		const length = bodyLengthChecker(data) || 0;
+		if (length === 0) return;
+		awsChunkedEncodingStream.push(`${length.toString(16)}\r\n`);
+		awsChunkedEncodingStream.push(data);
+		awsChunkedEncodingStream.push("\r\n");
+	});
+	readable.on("end", async () => {
+		awsChunkedEncodingStream.push(`0\r\n`);
+		if (checksumRequired) {
+			const checksum = base64Encoder(await digest);
+			awsChunkedEncodingStream.push(`${checksumLocationName}:${checksum}\r\n`);
+			awsChunkedEncodingStream.push(`\r\n`);
+		}
+		awsChunkedEncodingStream.push(null);
+	});
+	return awsChunkedEncodingStream;
+}
+var init_getAwsChunkedEncodingStream = __esmMin((() => {
+	init_getAwsChunkedEncodingStream_browser();
+	init_stream_type_check();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/headStream.browser.js
+async function headStream$1(stream, bytes) {
+	let byteLengthCounter = 0;
+	const chunks = [];
+	const reader = stream.getReader();
+	let isDone = false;
+	while (!isDone) {
+		const { done, value } = await reader.read();
+		if (value) {
+			chunks.push(value);
+			byteLengthCounter += value?.byteLength ?? 0;
+		}
+		if (byteLengthCounter >= bytes) break;
+		isDone = done;
+	}
+	reader.releaseLock();
+	const collected = new Uint8Array(Math.min(bytes, byteLengthCounter));
+	let offset = 0;
+	for (const chunk of chunks) {
+		if (chunk.byteLength > collected.byteLength - offset) {
+			collected.set(chunk.subarray(0, collected.byteLength - offset), offset);
+			break;
+		} else collected.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return collected;
+}
+var init_headStream_browser = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/headStream.js
+var headStream, Collector$1;
+var init_headStream = __esmMin((() => {
+	init_concatBytes();
+	init_headStream_browser();
+	init_stream_type_check();
+	headStream = (stream, bytes) => {
+		if (isReadableStream(stream)) return headStream$1(stream, bytes);
+		return new Promise((resolve, reject) => {
+			const collector = new Collector$1();
+			collector.limit = bytes;
+			stream.pipe(collector);
+			stream.on("error", (err) => {
+				collector.end();
+				reject(err);
+			});
+			collector.on("error", reject);
+			collector.on("finish", function() {
+				resolve(concatBytes(this.buffers));
+			});
+		});
+	};
+	Collector$1 = class extends Writable {
+		buffers = [];
+		limit = Infinity;
+		bytesBuffered = 0;
+		_write(chunk, encoding, callback) {
+			this.buffers.push(chunk);
+			this.bytesBuffered += chunk.byteLength ?? 0;
+			if (this.bytesBuffered >= this.limit) {
+				const excess = this.bytesBuffered - this.limit;
+				const tailBuffer = this.buffers[this.buffers.length - 1];
+				this.buffers[this.buffers.length - 1] = tailBuffer.subarray(0, tailBuffer.byteLength - excess);
+				this.emit("finish");
+			}
+			callback();
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-utf8/toUtf8.browser.js
+var toUtf8;
+var init_toUtf8_browser = __esmMin((() => {
+	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 new TextDecoder("utf-8").decode(input);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.browser.js
+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);
+}
+var streamCollector$1;
+var init_stream_collector_browser = __esmMin((() => {
+	init_concatBytes();
+	init_stream_type_check();
+	streamCollector$1 = async (stream) => {
+		if (isBlob(stream)) return collectBlob(stream);
+		return collectReadableStream(stream);
+	};
+}));
+//#endregion
+//#region ../../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$1, sdkStreamMixin$1, isBlobInstance;
+var init_sdk_stream_mixin_browser = __esmMin((() => {
+	init_toBase64_browser();
+	init_hex_encoding();
+	init_toUtf8_browser();
+	init_stream_collector_browser();
+	init_stream_type_check();
+	ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED$1 = "The stream has already been transformed.";
+	sdkStreamMixin$1 = (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$1);
+			transformed = true;
+			return await streamCollector$1(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 toBase64(buf);
+				else if (encoding === "hex") return toHex(buf);
+				else if (encoding === void 0 || encoding === "utf8" || encoding === "utf-8") return toUtf8(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$1);
+				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}`);
+			}
+		});
+	};
+	isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/stream-collector.js
+var streamCollector, Collector;
+var init_stream_collector = __esmMin((() => {
+	init_concatBytes();
+	init_stream_collector_browser();
+	init_stream_type_check();
+	streamCollector = (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() {
+				resolve(concatBytes(this.bufferedBytes));
+			});
+		});
+	};
+	Collector = class extends Writable {
+		bufferedBytes = [];
+		_write(chunk, encoding, callback) {
+			this.bufferedBytes.push(chunk);
+			callback();
+		}
+	};
+}));
+//#endregion
+//#region ../../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_TRANSFORMED, sdkStreamMixin;
+var init_sdk_stream_mixin = __esmMin((() => {
+	init_buffer_from();
+	init_sdk_stream_mixin_browser();
+	init_stream_collector();
+	ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
+	sdkStreamMixin = (stream) => {
+		if (!(stream instanceof Readable)) try {
+			return sdkStreamMixin$1(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_TRANSFORMED);
+			transformed = true;
+			return await streamCollector(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 return new TextDecoder(encoding).decode(buf);
+			},
+			transformToWebStream: () => {
+				if (transformed) throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
+				if (stream.readableFlowing !== null) throw new Error("The stream has been consumed by other callbacks.");
+				if (typeof Readable.toWeb !== "function") throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
+				transformed = true;
+				return Readable.toWeb(stream);
+			}
+		});
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/splitStream.browser.js
+async function splitStream$1(stream) {
+	if (typeof stream.stream === "function") stream = stream.stream();
+	return stream.tee();
+}
+var init_splitStream_browser = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/splitStream.js
+async function splitStream(stream) {
+	if (isReadableStream(stream) || isBlob(stream)) return splitStream$1(stream);
+	const stream1 = new PassThrough();
+	const stream2 = new PassThrough();
+	stream.pipe(stream1);
+	stream.pipe(stream2);
+	return [stream1, stream2];
+}
+var init_splitStream = __esmMin((() => {
+	init_splitStream_browser();
+	init_stream_type_check();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.33.3/node_modules/@smithy/core/dist-es/submodules/serde/index.js
+var serde_exports = /* @__PURE__ */ __exportAll({
+	ChecksumStream: () => ChecksumStream$1,
+	Hash: () => Hash,
+	LazyJsonString: () => LazyJsonString,
+	NumericValue: () => NumericValue,
+	Uint8ArrayBlobAdapter: () => Uint8ArrayBlobAdapter,
+	_parseEpochTimestamp: () => _parseEpochTimestamp,
+	_parseRfc3339DateTimeWithOffset: () => _parseRfc3339DateTimeWithOffset,
+	_parseRfc7231DateTime: () => _parseRfc7231DateTime,
+	calculateBodyLength: () => calculateBodyLength,
+	concatBytes: () => concatBytes,
+	copyDocumentWithTransform: () => copyDocumentWithTransform,
+	createBufferedReadable: () => createBufferedReadable,
+	createChecksumStream: () => createChecksumStream,
+	dateToUtcString: () => dateToUtcString,
+	deserializerMiddleware: () => deserializerMiddleware,
+	deserializerMiddlewareOption: () => deserializerMiddlewareOption,
+	expectBoolean: () => expectBoolean,
+	expectByte: () => expectByte,
+	expectFloat32: () => expectFloat32,
+	expectInt: () => expectInt,
+	expectInt32: () => expectInt32,
+	expectLong: () => expectLong,
+	expectNonNull: () => expectNonNull,
+	expectNumber: () => expectNumber,
+	expectObject: () => expectObject,
+	expectShort: () => expectShort,
+	expectString: () => expectString,
+	expectUnion: () => expectUnion,
+	fromArrayBuffer: () => fromArrayBuffer,
+	fromBase64: () => fromBase64,
+	fromHex: () => fromHex,
+	fromString: () => fromString,
+	fromUtf8: () => fromUtf8$1,
+	generateIdempotencyToken: () => generateIdempotencyToken,
+	getAwsChunkedEncodingStream: () => getAwsChunkedEncodingStream,
+	getSerdePlugin: () => getSerdePlugin,
+	handleFloat: () => handleFloat,
+	hasOwn: () => hasOwn,
+	headStream: () => headStream,
+	isArrayBuffer: () => isArrayBuffer,
+	isBlob: () => isBlob,
+	isReadableStream: () => isReadableStream,
+	limitedParseDouble: () => limitedParseDouble,
+	limitedParseFloat: () => limitedParseFloat,
+	limitedParseFloat32: () => limitedParseFloat32,
+	logger: () => logger,
+	nv: () => nv,
+	parseBoolean: () => parseBoolean,
+	parseEpochTimestamp: () => parseEpochTimestamp,
+	parseRfc3339DateTime: () => parseRfc3339DateTime,
+	parseRfc3339DateTimeWithOffset: () => parseRfc3339DateTimeWithOffset,
+	parseRfc7231DateTime: () => parseRfc7231DateTime,
+	quoteHeader: () => quoteHeader,
+	sdkStreamMixin: () => sdkStreamMixin,
+	serializerMiddleware: () => serializerMiddleware,
+	serializerMiddlewareOption: () => serializerMiddlewareOption,
+	splitEvery: () => splitEvery,
+	splitHeader: () => splitHeader,
+	splitStream: () => splitStream,
+	streamCollector: () => streamCollector,
+	strictParseByte: () => strictParseByte,
+	strictParseDouble: () => strictParseDouble,
+	strictParseFloat: () => strictParseFloat,
+	strictParseFloat32: () => strictParseFloat32,
+	strictParseInt: () => strictParseInt,
+	strictParseInt32: () => strictParseInt32,
+	strictParseLong: () => strictParseLong,
+	strictParseShort: () => strictParseShort,
+	toBase64: () => toBase64$1,
+	toHex: () => toHex,
+	toUint8Array: () => toUint8Array,
+	toUtf8: () => toUtf8$1,
+	v4: () => v4
+});
+var Uint8ArrayBlobAdapter, _getRandomValues, v4, generateIdempotencyToken;
+var init_serde = __esmMin((() => {
+	init_fromBase64();
+	init_toBase64();
+	init_Uint8ArrayBlobAdapter();
+	init_fromUtf8();
+	init_toUtf8();
+	init_v4();
+	init_copyDocumentWithTransform();
+	init_date_utils();
+	init_lazy_json();
+	init_parse_utils();
+	init_quote_header();
+	init_schema_date_utils();
+	init_split_every();
+	init_split_header();
+	init_NumericValue();
+	init_hex_encoding();
+	init_calculateBodyLength();
+	init_toUint8Array();
+	init_concatBytes();
+	init_buffer_from();
+	init_is_array_buffer();
+	init_deserializerMiddleware();
+	init_serdePlugin();
+	init_serializerMiddleware();
+	init_hash_node();
+	init_ChecksumStream();
+	init_createChecksumStream();
+	init_createBufferedReadable();
+	init_getAwsChunkedEncodingStream();
+	init_headStream();
+	init_sdk_stream_mixin();
+	init_splitStream();
+	init_stream_type_check();
+	init_stream_collector();
+	init_transport();
+	Uint8ArrayBlobAdapter = class extends bindUint8ArrayBlobAdapter(toUtf8$1, fromUtf8$1, toBase64$1, fromBase64) {};
+	_getRandomValues = getRandomValues;
+	v4 = bindV4(_getRandomValues);
+	generateIdempotencyToken = v4;
+}));
+//#endregion
+export { toBase64$1 as $, init_lazy_json as A, init_isValidHostname as B, _parseEpochTimestamp as C, init_quote_header as D, init_schema_date_utils as E, parseUrl as F, init_httpRequest as G, HttpResponse as H, init_parseQueryString as I, getSmithyContext as J, hasOwn as K, parseQueryString as L, init_date_utils as M, init_transport as N, quoteHeader as O, init_parseUrl as P, init_toBase64 as Q, init_normalizeProvider as R, splitEvery as S, _parseRfc7231DateTime as T, init_httpResponse as U, isValidHostname as V, HttpRequest as W, init_toUtf8 as X, init_getSmithyContext as Y, toUtf8$1 as Z, NumericValue as _, init_sdk_stream_mixin as a, splitHeader as b, TypeRegistry as c, init_NormalizedSchema as d, fromUtf8$1 as et, init_translateTraits as f, toHex as g, init_hex_encoding as h, serde_exports as i, dateToUtcString as j, LazyJsonString as k, init_TypeRegistry as l, fromHex as m, generateIdempotencyToken as n, fromBase64 as nt, sdkStreamMixin as o, translateTraits as p, init_hasOwn as q, init_serde as r, init_fromBase64 as rt, init_schema as s, Uint8ArrayBlobAdapter as t, init_fromUtf8 as tt, NormalizedSchema as u, init_NumericValue as v, _parseRfc3339DateTimeWithOffset as w, init_split_every as x, init_split_header as y, normalizeProvider as z };
+
+//# sourceMappingURL=serde-Cq0wappq.js.map