@vercube/storage 0.0.22 → 0.0.24

package/dist/schema-DfAlCaU9.mjs

@@ -0,0 +1,1176 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames$6 = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames$6(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames$6(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export$6 = (all) => {
+	let target = {};
+	for (var name in all) __defProp$6(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps$6 = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames$6(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp$6.call(to, key) && key !== except) __defProp$6(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc$6(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps$6(isNodeMode || !mod || !mod.__esModule ? __defProp$6(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS$6 = (mod) => __copyProps$6(__defProp$6({}, "__esModule", { value: true }), mod);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+types@4.5.0/node_modules/@smithy/types/dist-cjs/index.js
+var require_dist_cjs$5 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@smithy+types@4.5.0/node_modules/@smithy/types/dist-cjs/index.js": ((exports, module) => {
+	var __defProp$5 = Object.defineProperty;
+	var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames$5 = Object.getOwnPropertyNames;
+	var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+	var __name$5 = (target, value) => __defProp$5(target, "name", {
+		value,
+		configurable: true
+	});
+	var __export$5 = (target, all) => {
+		for (var name in all) __defProp$5(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	};
+	var __copyProps$5 = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (let key of __getOwnPropNames$5(from)) if (!__hasOwnProp$5.call(to, key) && key !== except) __defProp$5(to, key, {
+				get: () => from[key],
+				enumerable: !(desc = __getOwnPropDesc$5(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toCommonJS$5 = (mod) => __copyProps$5(__defProp$5({}, "__esModule", { value: true }), mod);
+	var index_exports$5 = {};
+	__export$5(index_exports$5, {
+		AlgorithmId: () => AlgorithmId,
+		EndpointURLScheme: () => EndpointURLScheme,
+		FieldPosition: () => FieldPosition,
+		HttpApiKeyAuthLocation: () => HttpApiKeyAuthLocation,
+		HttpAuthLocation: () => HttpAuthLocation,
+		IniSectionType: () => IniSectionType,
+		RequestHandlerProtocol: () => RequestHandlerProtocol,
+		SMITHY_CONTEXT_KEY: () => SMITHY_CONTEXT_KEY,
+		getDefaultClientConfiguration: () => getDefaultClientConfiguration,
+		resolveDefaultRuntimeConfig: () => resolveDefaultRuntimeConfig
+	});
+	module.exports = __toCommonJS$5(index_exports$5);
+	var HttpAuthLocation = /* @__PURE__ */ ((HttpAuthLocation2) => {
+		HttpAuthLocation2["HEADER"] = "header";
+		HttpAuthLocation2["QUERY"] = "query";
+		return HttpAuthLocation2;
+	})(HttpAuthLocation || {});
+	var HttpApiKeyAuthLocation = /* @__PURE__ */ ((HttpApiKeyAuthLocation2) => {
+		HttpApiKeyAuthLocation2["HEADER"] = "header";
+		HttpApiKeyAuthLocation2["QUERY"] = "query";
+		return HttpApiKeyAuthLocation2;
+	})(HttpApiKeyAuthLocation || {});
+	var EndpointURLScheme = /* @__PURE__ */ ((EndpointURLScheme2) => {
+		EndpointURLScheme2["HTTP"] = "http";
+		EndpointURLScheme2["HTTPS"] = "https";
+		return EndpointURLScheme2;
+	})(EndpointURLScheme || {});
+	var AlgorithmId = /* @__PURE__ */ ((AlgorithmId2) => {
+		AlgorithmId2["MD5"] = "md5";
+		AlgorithmId2["CRC32"] = "crc32";
+		AlgorithmId2["CRC32C"] = "crc32c";
+		AlgorithmId2["SHA1"] = "sha1";
+		AlgorithmId2["SHA256"] = "sha256";
+		return AlgorithmId2;
+	})(AlgorithmId || {});
+	var getChecksumConfiguration = /* @__PURE__ */ __name$5((runtimeConfig) => {
+		const checksumAlgorithms = [];
+		if (runtimeConfig.sha256 !== void 0) checksumAlgorithms.push({
+			algorithmId: /* @__PURE__ */ __name$5(() => "sha256", "algorithmId"),
+			checksumConstructor: /* @__PURE__ */ __name$5(() => runtimeConfig.sha256, "checksumConstructor")
+		});
+		if (runtimeConfig.md5 != void 0) checksumAlgorithms.push({
+			algorithmId: /* @__PURE__ */ __name$5(() => "md5", "algorithmId"),
+			checksumConstructor: /* @__PURE__ */ __name$5(() => runtimeConfig.md5, "checksumConstructor")
+		});
+		return {
+			addChecksumAlgorithm(algo) {
+				checksumAlgorithms.push(algo);
+			},
+			checksumAlgorithms() {
+				return checksumAlgorithms;
+			}
+		};
+	}, "getChecksumConfiguration");
+	var resolveChecksumRuntimeConfig = /* @__PURE__ */ __name$5((clientConfig) => {
+		const runtimeConfig = {};
+		clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
+			runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
+		});
+		return runtimeConfig;
+	}, "resolveChecksumRuntimeConfig");
+	var getDefaultClientConfiguration = /* @__PURE__ */ __name$5((runtimeConfig) => {
+		return getChecksumConfiguration(runtimeConfig);
+	}, "getDefaultClientConfiguration");
+	var resolveDefaultRuntimeConfig = /* @__PURE__ */ __name$5((config) => {
+		return resolveChecksumRuntimeConfig(config);
+	}, "resolveDefaultRuntimeConfig");
+	var FieldPosition = /* @__PURE__ */ ((FieldPosition2) => {
+		FieldPosition2[FieldPosition2["HEADER"] = 0] = "HEADER";
+		FieldPosition2[FieldPosition2["TRAILER"] = 1] = "TRAILER";
+		return FieldPosition2;
+	})(FieldPosition || {});
+	var SMITHY_CONTEXT_KEY = "__smithy_context";
+	var IniSectionType = /* @__PURE__ */ ((IniSectionType2) => {
+		IniSectionType2["PROFILE"] = "profile";
+		IniSectionType2["SSO_SESSION"] = "sso-session";
+		IniSectionType2["SERVICES"] = "services";
+		return IniSectionType2;
+	})(IniSectionType || {});
+	var RequestHandlerProtocol = /* @__PURE__ */ ((RequestHandlerProtocol2) => {
+		RequestHandlerProtocol2["HTTP_0_9"] = "http/0.9";
+		RequestHandlerProtocol2["HTTP_1_0"] = "http/1.0";
+		RequestHandlerProtocol2["TDS_8_0"] = "tds/8.0";
+		return RequestHandlerProtocol2;
+	})(RequestHandlerProtocol || {});
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+protocol-http@5.2.1/node_modules/@smithy/protocol-http/dist-cjs/index.js
+var require_dist_cjs$4 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@smithy+protocol-http@5.2.1/node_modules/@smithy/protocol-http/dist-cjs/index.js": ((exports, module) => {
+	var __defProp$4 = Object.defineProperty;
+	var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames$4 = Object.getOwnPropertyNames;
+	var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+	var __name$4 = (target, value) => __defProp$4(target, "name", {
+		value,
+		configurable: true
+	});
+	var __export$4 = (target, all) => {
+		for (var name in all) __defProp$4(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	};
+	var __copyProps$4 = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (let key of __getOwnPropNames$4(from)) if (!__hasOwnProp$4.call(to, key) && key !== except) __defProp$4(to, key, {
+				get: () => from[key],
+				enumerable: !(desc = __getOwnPropDesc$4(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toCommonJS$4 = (mod) => __copyProps$4(__defProp$4({}, "__esModule", { value: true }), mod);
+	var index_exports$4 = {};
+	__export$4(index_exports$4, {
+		Field: () => Field,
+		Fields: () => Fields,
+		HttpRequest: () => HttpRequest,
+		HttpResponse: () => HttpResponse$1,
+		IHttpRequest: () => import_types$1.HttpRequest,
+		getHttpHandlerExtensionConfiguration: () => getHttpHandlerExtensionConfiguration,
+		isValidHostname: () => isValidHostname,
+		resolveHttpHandlerRuntimeConfig: () => resolveHttpHandlerRuntimeConfig
+	});
+	module.exports = __toCommonJS$4(index_exports$4);
+	var getHttpHandlerExtensionConfiguration = /* @__PURE__ */ __name$4((runtimeConfig) => {
+		return {
+			setHttpHandler(handler) {
+				runtimeConfig.httpHandler = handler;
+			},
+			httpHandler() {
+				return runtimeConfig.httpHandler;
+			},
+			updateHttpClientConfig(key, value) {
+				runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
+			},
+			httpHandlerConfigs() {
+				return runtimeConfig.httpHandler.httpHandlerConfigs();
+			}
+		};
+	}, "getHttpHandlerExtensionConfiguration");
+	var resolveHttpHandlerRuntimeConfig = /* @__PURE__ */ __name$4((httpHandlerExtensionConfiguration) => {
+		return { httpHandler: httpHandlerExtensionConfiguration.httpHandler() };
+	}, "resolveHttpHandlerRuntimeConfig");
+	var import_types$1 = require_dist_cjs$5();
+	var Field = class {
+		static {
+			__name$4(this, "Field");
+		}
+		constructor({ name, kind = import_types$1.FieldPosition.HEADER, values = [] }) {
+			this.name = name;
+			this.kind = kind;
+			this.values = values;
+		}
+		/**
+		* Appends a value to the field.
+		*
+		* @param value The value to append.
+		*/
+		add(value) {
+			this.values.push(value);
+		}
+		/**
+		* Overwrite existing field values.
+		*
+		* @param values The new field values.
+		*/
+		set(values) {
+			this.values = values;
+		}
+		/**
+		* Remove all matching entries from list.
+		*
+		* @param value Value to remove.
+		*/
+		remove(value) {
+			this.values = this.values.filter((v) => v !== value);
+		}
+		/**
+		* Get comma-delimited string.
+		*
+		* @returns String representation of {@link Field}.
+		*/
+		toString() {
+			return this.values.map((v) => v.includes(",") || v.includes(" ") ? `"${v}"` : v).join(", ");
+		}
+		/**
+		* Get string values as a list
+		*
+		* @returns Values in {@link Field} as a list.
+		*/
+		get() {
+			return this.values;
+		}
+	};
+	var Fields = class {
+		constructor({ fields = [], encoding = "utf-8" }) {
+			this.entries = {};
+			fields.forEach(this.setField.bind(this));
+			this.encoding = encoding;
+		}
+		static {
+			__name$4(this, "Fields");
+		}
+		/**
+		* Set entry for a {@link Field} name. The `name`
+		* attribute will be used to key the collection.
+		*
+		* @param field The {@link Field} to set.
+		*/
+		setField(field) {
+			this.entries[field.name.toLowerCase()] = field;
+		}
+		/**
+		*  Retrieve {@link Field} entry by name.
+		*
+		* @param name The name of the {@link Field} entry
+		*  to retrieve
+		* @returns The {@link Field} if it exists.
+		*/
+		getField(name) {
+			return this.entries[name.toLowerCase()];
+		}
+		/**
+		* Delete entry from collection.
+		*
+		* @param name Name of the entry to delete.
+		*/
+		removeField(name) {
+			delete this.entries[name.toLowerCase()];
+		}
+		/**
+		* Helper function for retrieving specific types of fields.
+		* Used to grab all headers or all trailers.
+		*
+		* @param kind {@link FieldPosition} of entries to retrieve.
+		* @returns The {@link Field} entries with the specified
+		*  {@link FieldPosition}.
+		*/
+		getByType(kind) {
+			return Object.values(this.entries).filter((field) => field.kind === kind);
+		}
+	};
+	var HttpRequest = class _HttpRequest {
+		static {
+			__name$4(this, "HttpRequest");
+		}
+		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;
+		}
+		/**
+		* Note: this does not deep-clone the body.
+		*/
+		static clone(request) {
+			const cloned = new _HttpRequest({
+				...request,
+				headers: { ...request.headers }
+			});
+			if (cloned.query) cloned.query = cloneQuery(cloned.query);
+			return cloned;
+		}
+		/**
+		* This method only actually asserts that request is the interface {@link IHttpRequest},
+		* and not necessarily this concrete class. Left in place for API stability.
+		*
+		* Do not call instance methods on the input of this function, and
+		* do not assume it has the HttpRequest prototype.
+		*/
+		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";
+		}
+		/**
+		* @deprecated use static HttpRequest.clone(request) instead. It's not safe to call
+		* this method because {@link HttpRequest.isInstance} incorrectly
+		* asserts that IHttpRequest (interface) objects are of type HttpRequest (class).
+		*/
+		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
+			};
+		}, {});
+	}
+	__name$4(cloneQuery, "cloneQuery");
+	var HttpResponse$1 = class {
+		static {
+			__name$4(this, "HttpResponse");
+		}
+		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";
+		}
+	};
+	function isValidHostname(hostname) {
+		return /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/.test(hostname);
+	}
+	__name$4(isValidHostname, "isValidHostname");
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+util-middleware@4.1.1/node_modules/@smithy/util-middleware/dist-cjs/index.js
+var require_dist_cjs$3 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@smithy+util-middleware@4.1.1/node_modules/@smithy/util-middleware/dist-cjs/index.js": ((exports, module) => {
+	var __defProp$3 = Object.defineProperty;
+	var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames$3 = Object.getOwnPropertyNames;
+	var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+	var __name$3 = (target, value) => __defProp$3(target, "name", {
+		value,
+		configurable: true
+	});
+	var __export$3 = (target, all) => {
+		for (var name in all) __defProp$3(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	};
+	var __copyProps$3 = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (let key of __getOwnPropNames$3(from)) if (!__hasOwnProp$3.call(to, key) && key !== except) __defProp$3(to, key, {
+				get: () => from[key],
+				enumerable: !(desc = __getOwnPropDesc$3(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toCommonJS$3 = (mod) => __copyProps$3(__defProp$3({}, "__esModule", { value: true }), mod);
+	var index_exports$3 = {};
+	__export$3(index_exports$3, {
+		getSmithyContext: () => getSmithyContext$2,
+		normalizeProvider: () => normalizeProvider
+	});
+	module.exports = __toCommonJS$3(index_exports$3);
+	var import_types = require_dist_cjs$5();
+	var getSmithyContext$2 = /* @__PURE__ */ __name$3((context) => context[import_types.SMITHY_CONTEXT_KEY] || (context[import_types.SMITHY_CONTEXT_KEY] = {}), "getSmithyContext");
+	var normalizeProvider = /* @__PURE__ */ __name$3((input) => {
+		if (typeof input === "function") return input;
+		const promisified = Promise.resolve(input);
+		return () => promisified;
+	}, "normalizeProvider");
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+is-array-buffer@4.1.0/node_modules/@smithy/is-array-buffer/dist-cjs/index.js
+var require_dist_cjs$2 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@smithy+is-array-buffer@4.1.0/node_modules/@smithy/is-array-buffer/dist-cjs/index.js": ((exports, module) => {
+	var __defProp$2 = Object.defineProperty;
+	var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames$2 = Object.getOwnPropertyNames;
+	var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+	var __name$2 = (target, value) => __defProp$2(target, "name", {
+		value,
+		configurable: true
+	});
+	var __export$2 = (target, all) => {
+		for (var name in all) __defProp$2(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	};
+	var __copyProps$2 = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (let key of __getOwnPropNames$2(from)) if (!__hasOwnProp$2.call(to, key) && key !== except) __defProp$2(to, key, {
+				get: () => from[key],
+				enumerable: !(desc = __getOwnPropDesc$2(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toCommonJS$2 = (mod) => __copyProps$2(__defProp$2({}, "__esModule", { value: true }), mod);
+	var index_exports$2 = {};
+	__export$2(index_exports$2, { isArrayBuffer: () => isArrayBuffer });
+	module.exports = __toCommonJS$2(index_exports$2);
+	var isArrayBuffer = /* @__PURE__ */ __name$2((arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]", "isArrayBuffer");
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+util-buffer-from@4.1.0/node_modules/@smithy/util-buffer-from/dist-cjs/index.js
+var require_dist_cjs$1 = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@smithy+util-buffer-from@4.1.0/node_modules/@smithy/util-buffer-from/dist-cjs/index.js": ((exports, module) => {
+	var __defProp$1 = Object.defineProperty;
+	var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames$1 = Object.getOwnPropertyNames;
+	var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+	var __name$1 = (target, value) => __defProp$1(target, "name", {
+		value,
+		configurable: true
+	});
+	var __export$1 = (target, all) => {
+		for (var name in all) __defProp$1(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	};
+	var __copyProps$1 = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (let key of __getOwnPropNames$1(from)) if (!__hasOwnProp$1.call(to, key) && key !== except) __defProp$1(to, key, {
+				get: () => from[key],
+				enumerable: !(desc = __getOwnPropDesc$1(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toCommonJS$1 = (mod) => __copyProps$1(__defProp$1({}, "__esModule", { value: true }), mod);
+	var index_exports$1 = {};
+	__export$1(index_exports$1, {
+		fromArrayBuffer: () => fromArrayBuffer,
+		fromString: () => fromString
+	});
+	module.exports = __toCommonJS$1(index_exports$1);
+	var import_is_array_buffer = require_dist_cjs$2();
+	var import_buffer = __require("buffer");
+	var fromArrayBuffer = /* @__PURE__ */ __name$1((input, offset = 0, length = input.byteLength - offset) => {
+		if (!(0, import_is_array_buffer.isArrayBuffer)(input)) throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
+		return import_buffer.Buffer.from(input, offset, length);
+	}, "fromArrayBuffer");
+	var fromString = /* @__PURE__ */ __name$1((input, encoding) => {
+		if (typeof input !== "string") throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+		return encoding ? import_buffer.Buffer.from(input, encoding) : import_buffer.Buffer.from(input);
+	}, "fromString");
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+util-utf8@4.1.0/node_modules/@smithy/util-utf8/dist-cjs/index.js
+var require_dist_cjs = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/@smithy+util-utf8@4.1.0/node_modules/@smithy/util-utf8/dist-cjs/index.js": ((exports, module) => {
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __name = (target, value) => __defProp(target, "name", {
+		value,
+		configurable: true
+	});
+	var __export = (target, all) => {
+		for (var name in all) __defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	};
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") {
+			for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: () => from[key],
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+	var index_exports = {};
+	__export(index_exports, {
+		fromUtf8: () => fromUtf8,
+		toUint8Array: () => toUint8Array,
+		toUtf8: () => toUtf8
+	});
+	module.exports = __toCommonJS(index_exports);
+	var import_util_buffer_from = require_dist_cjs$1();
+	var fromUtf8 = /* @__PURE__ */ __name((input) => {
+		const buf = (0, import_util_buffer_from.fromString)(input, "utf8");
+		return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+	}, "fromUtf8");
+	var toUint8Array = /* @__PURE__ */ __name((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);
+	}, "toUint8Array");
+	var toUtf8 = /* @__PURE__ */ __name((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 (0, import_util_buffer_from.fromArrayBuffer)(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+	}, "toUtf8");
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/deref.js
+var deref;
+var init_deref = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/deref.js": (() => {
+	deref = (schemaRef) => {
+		if (typeof schemaRef === "function") return schemaRef();
+		return schemaRef;
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js
+var import_dist_cjs$1, import_dist_cjs$2, schemaDeserializationMiddleware, findHeader;
+var init_schemaDeserializationMiddleware = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js": (() => {
+	import_dist_cjs$1 = /* @__PURE__ */ __toESM(require_dist_cjs$4());
+	import_dist_cjs$2 = /* @__PURE__ */ __toESM(require_dist_cjs$3());
+	schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
+		const { response } = await next(args);
+		const { operationSchema } = (0, import_dist_cjs$2.getSmithyContext)(context);
+		try {
+			const parsed = await config.protocol.deserializeResponse(operationSchema, {
+				...config,
+				...context
+			}, response);
+			return {
+				response,
+				output: parsed
+			};
+		} catch (error$1) {
+			Object.defineProperty(error$1, "$response", { value: response });
+			if (!("$metadata" in error$1)) {
+				const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
+				try {
+					error$1.message += "\n  " + hint;
+				} catch (e) {
+					if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") console.warn(hint);
+					else context.logger?.warn?.(hint);
+				}
+				if (typeof error$1.$responseBodyText !== "undefined") {
+					if (error$1.$response) error$1.$response.body = error$1.$responseBodyText;
+				}
+				try {
+					if (import_dist_cjs$1.HttpResponse.isInstance(response)) {
+						const { headers = {} } = response;
+						const headerEntries = Object.entries(headers);
+						error$1.$metadata = {
+							httpStatusCode: response.statusCode,
+							requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
+							extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
+							cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
+						};
+					}
+				} catch (e) {}
+			}
+			throw error$1;
+		}
+	};
+	findHeader = (pattern, headers) => {
+		return (headers.find(([k]) => {
+			return k.match(pattern);
+		}) || [void 0, void 0])[1];
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js
+var import_dist_cjs, schemaSerializationMiddleware;
+var init_schemaSerializationMiddleware = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js": (() => {
+	import_dist_cjs = /* @__PURE__ */ __toESM(require_dist_cjs$3());
+	schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
+		const { operationSchema } = (0, import_dist_cjs.getSmithyContext)(context);
+		const endpoint = context.endpointV2?.url && config.urlParser ? async () => config.urlParser(context.endpointV2.url) : config.endpoint;
+		const request = await config.protocol.serializeRequest(operationSchema, args.input, {
+			...config,
+			...context,
+			endpoint
+		});
+		return next({
+			...args,
+			request
+		});
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js
+function getSchemaSerdePlugin(config) {
+	return { applyToStack: (commandStack) => {
+		commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
+		commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
+		config.protocol.setSerdeContext(config);
+	} };
+}
+var deserializerMiddlewareOption, serializerMiddlewareOption;
+var init_getSchemaSerdePlugin = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js": (() => {
+	init_schemaDeserializationMiddleware();
+	init_schemaSerializationMiddleware();
+	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.11.1/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js
+var TypeRegistry;
+var init_TypeRegistry = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js": (() => {
+	TypeRegistry = class TypeRegistry {
+		constructor(namespace, schemas = /* @__PURE__ */ new Map()) {
+			this.namespace = namespace;
+			this.schemas = schemas;
+		}
+		static for(namespace) {
+			if (!TypeRegistry.registries.has(namespace)) TypeRegistry.registries.set(namespace, new TypeRegistry(namespace));
+			return TypeRegistry.registries.get(namespace);
+		}
+		register(shapeId, schema) {
+			const qualifiedName = this.normalizeShapeId(shapeId);
+			TypeRegistry.for(this.getNamespace(shapeId)).schemas.set(qualifiedName, schema);
+		}
+		getSchema(shapeId) {
+			const id = this.normalizeShapeId(shapeId);
+			if (!this.schemas.has(id)) throw new Error(`@smithy/core/schema - schema not found for ${id}`);
+			return this.schemas.get(id);
+		}
+		getBaseException() {
+			for (const [id, schema] of this.schemas.entries()) if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) return schema;
+		}
+		find(predicate) {
+			return [...this.schemas.values()].find(predicate);
+		}
+		destroy() {
+			TypeRegistry.registries.delete(this.namespace);
+			this.schemas.clear();
+		}
+		normalizeShapeId(shapeId) {
+			if (shapeId.includes("#")) return shapeId;
+			return this.namespace + "#" + shapeId;
+		}
+		getNamespace(shapeId) {
+			return this.normalizeShapeId(shapeId).split("#")[0];
+		}
+	};
+	TypeRegistry.registries = /* @__PURE__ */ new Map();
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js
+var Schema;
+var init_Schema = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js": (() => {
+	init_TypeRegistry();
+	Schema = class {
+		static assign(instance, values) {
+			const schema = Object.assign(instance, values);
+			TypeRegistry.for(schema.namespace).register(schema.name, schema);
+			return schema;
+		}
+		static [Symbol.hasInstance](lhs) {
+			const isPrototype = this.prototype.isPrototypeOf(lhs);
+			if (!isPrototype && typeof lhs === "object" && lhs !== null) return lhs.symbol === this.symbol;
+			return isPrototype;
+		}
+		getName() {
+			return this.namespace + "#" + this.name;
+		}
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ListSchema.js
+var ListSchema, list;
+var init_ListSchema = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ListSchema.js": (() => {
+	init_Schema();
+	ListSchema = class ListSchema extends Schema {
+		constructor() {
+			super(...arguments);
+			this.symbol = ListSchema.symbol;
+		}
+	};
+	ListSchema.symbol = Symbol.for("@smithy/lis");
+	list = (namespace, name, traits, valueSchema) => Schema.assign(new ListSchema(), {
+		name,
+		namespace,
+		traits,
+		valueSchema
+	});
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/MapSchema.js
+var MapSchema, map;
+var init_MapSchema = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/MapSchema.js": (() => {
+	init_Schema();
+	MapSchema = class MapSchema extends Schema {
+		constructor() {
+			super(...arguments);
+			this.symbol = MapSchema.symbol;
+		}
+	};
+	MapSchema.symbol = Symbol.for("@smithy/map");
+	map = (namespace, name, traits, keySchema, valueSchema) => Schema.assign(new MapSchema(), {
+		name,
+		namespace,
+		traits,
+		keySchema,
+		valueSchema
+	});
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/OperationSchema.js
+var OperationSchema, op;
+var init_OperationSchema = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/OperationSchema.js": (() => {
+	init_Schema();
+	OperationSchema = class OperationSchema extends Schema {
+		constructor() {
+			super(...arguments);
+			this.symbol = OperationSchema.symbol;
+		}
+	};
+	OperationSchema.symbol = Symbol.for("@smithy/ope");
+	op = (namespace, name, traits, input, output) => Schema.assign(new OperationSchema(), {
+		name,
+		namespace,
+		traits,
+		input,
+		output
+	});
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js
+var StructureSchema, struct;
+var init_StructureSchema = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js": (() => {
+	init_Schema();
+	StructureSchema = class StructureSchema extends Schema {
+		constructor() {
+			super(...arguments);
+			this.symbol = StructureSchema.symbol;
+		}
+	};
+	StructureSchema.symbol = Symbol.for("@smithy/str");
+	struct = (namespace, name, traits, memberNames, memberList) => Schema.assign(new StructureSchema(), {
+		name,
+		namespace,
+		traits,
+		memberNames,
+		memberList
+	});
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js
+var ErrorSchema, error;
+var init_ErrorSchema = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js": (() => {
+	init_Schema();
+	init_StructureSchema();
+	ErrorSchema = class ErrorSchema extends StructureSchema {
+		constructor() {
+			super(...arguments);
+			this.symbol = ErrorSchema.symbol;
+		}
+	};
+	ErrorSchema.symbol = Symbol.for("@smithy/err");
+	error = (namespace, name, traits, memberNames, memberList, ctor) => Schema.assign(new ErrorSchema(), {
+		name,
+		namespace,
+		traits,
+		memberNames,
+		memberList,
+		ctor
+	});
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/sentinels.js
+var SCHEMA;
+var init_sentinels = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/sentinels.js": (() => {
+	SCHEMA = {
+		BLOB: 21,
+		STREAMING_BLOB: 42,
+		BOOLEAN: 2,
+		STRING: 0,
+		NUMERIC: 1,
+		BIG_INTEGER: 17,
+		BIG_DECIMAL: 19,
+		DOCUMENT: 15,
+		TIMESTAMP_DEFAULT: 4,
+		TIMESTAMP_DATE_TIME: 5,
+		TIMESTAMP_HTTP_DATE: 6,
+		TIMESTAMP_EPOCH_SECONDS: 7,
+		LIST_MODIFIER: 64,
+		MAP_MODIFIER: 128
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js
+var SimpleSchema, sim;
+var init_SimpleSchema = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js": (() => {
+	init_Schema();
+	SimpleSchema = class SimpleSchema extends Schema {
+		constructor() {
+			super(...arguments);
+			this.symbol = SimpleSchema.symbol;
+		}
+	};
+	SimpleSchema.symbol = Symbol.for("@smithy/sim");
+	sim = (namespace, name, schemaRef, traits) => Schema.assign(new SimpleSchema(), {
+		name,
+		namespace,
+		traits,
+		schemaRef
+	});
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js
+var NormalizedSchema;
+var init_NormalizedSchema = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js": (() => {
+	init_deref();
+	init_ListSchema();
+	init_MapSchema();
+	init_Schema();
+	init_sentinels();
+	init_SimpleSchema();
+	init_StructureSchema();
+	NormalizedSchema = class NormalizedSchema {
+		constructor(ref, memberName) {
+			this.ref = ref;
+			this.memberName = memberName;
+			this.symbol = NormalizedSchema.symbol;
+			const traitStack = [];
+			let _ref = ref;
+			let schema = ref;
+			this._isMemberSchema = false;
+			while (Array.isArray(_ref)) {
+				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, NormalizedSchema.translateTraits(traitSet));
+				}
+			} else this.memberTraits = 0;
+			if (schema instanceof NormalizedSchema) {
+				Object.assign(this, schema);
+				this.memberTraits = Object.assign({}, schema.getMemberTraits(), this.getMemberTraits());
+				this.normalizedTraits = void 0;
+				this.memberName = memberName ?? schema.memberName;
+				return;
+			}
+			this.schema = deref(schema);
+			if (this.schema && typeof this.schema === "object") this.traits = this.schema?.traits ?? {};
+			else this.traits = 0;
+			this.name = (this.schema instanceof Schema ? this.schema.getName?.() : void 0) ?? this.memberName ?? this.getSchemaName();
+			if (this._isMemberSchema && !memberName) throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
+		}
+		static [Symbol.hasInstance](lhs) {
+			return Schema[Symbol.hasInstance].bind(this)(lhs);
+		}
+		static of(ref) {
+			if (ref instanceof NormalizedSchema) return ref;
+			if (Array.isArray(ref)) {
+				const [ns, traits] = ref;
+				if (ns instanceof NormalizedSchema) {
+					Object.assign(ns.getMergedTraits(), NormalizedSchema.translateTraits(traits));
+					return ns;
+				}
+				throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`);
+			}
+			return new NormalizedSchema(ref);
+		}
+		static translateTraits(indicator) {
+			if (typeof indicator === "object") return indicator;
+			indicator = indicator | 0;
+			const traits = {};
+			let i = 0;
+			for (const trait of [
+				"httpLabel",
+				"idempotent",
+				"idempotencyToken",
+				"sensitive",
+				"httpPayload",
+				"httpResponseCode",
+				"httpQueryParams"
+			]) if ((indicator >> i++ & 1) === 1) traits[trait] = 1;
+			return traits;
+		}
+		getSchema() {
+			if (this.schema instanceof NormalizedSchema) {
+				Object.assign(this, { schema: this.schema.getSchema() });
+				return this.schema;
+			}
+			if (this.schema instanceof SimpleSchema) return deref(this.schema.schemaRef);
+			return deref(this.schema);
+		}
+		getName(withNamespace = false) {
+			if (!withNamespace) {
+				if (this.name && this.name.includes("#")) return this.name.split("#")[1];
+			}
+			return this.name || void 0;
+		}
+		getMemberName() {
+			if (!this.isMemberSchema()) throw new Error(`@smithy/core/schema - non-member schema: ${this.getName(true)}`);
+			return this.memberName;
+		}
+		isMemberSchema() {
+			return this._isMemberSchema;
+		}
+		isUnitSchema() {
+			return this.getSchema() === "unit";
+		}
+		isListSchema() {
+			const inner = this.getSchema();
+			if (typeof inner === "number") return inner >= SCHEMA.LIST_MODIFIER && inner < SCHEMA.MAP_MODIFIER;
+			return inner instanceof ListSchema;
+		}
+		isMapSchema() {
+			const inner = this.getSchema();
+			if (typeof inner === "number") return inner >= SCHEMA.MAP_MODIFIER && inner <= 255;
+			return inner instanceof MapSchema;
+		}
+		isStructSchema() {
+			const inner = this.getSchema();
+			return inner !== null && typeof inner === "object" && "members" in inner || inner instanceof StructureSchema;
+		}
+		isBlobSchema() {
+			return this.getSchema() === SCHEMA.BLOB || this.getSchema() === SCHEMA.STREAMING_BLOB;
+		}
+		isTimestampSchema() {
+			const schema = this.getSchema();
+			return typeof schema === "number" && schema >= SCHEMA.TIMESTAMP_DEFAULT && schema <= SCHEMA.TIMESTAMP_EPOCH_SECONDS;
+		}
+		isDocumentSchema() {
+			return this.getSchema() === SCHEMA.DOCUMENT;
+		}
+		isStringSchema() {
+			return this.getSchema() === SCHEMA.STRING;
+		}
+		isBooleanSchema() {
+			return this.getSchema() === SCHEMA.BOOLEAN;
+		}
+		isNumericSchema() {
+			return this.getSchema() === SCHEMA.NUMERIC;
+		}
+		isBigIntegerSchema() {
+			return this.getSchema() === SCHEMA.BIG_INTEGER;
+		}
+		isBigDecimalSchema() {
+			return this.getSchema() === SCHEMA.BIG_DECIMAL;
+		}
+		isStreaming() {
+			if (!!this.getMergedTraits().streaming) return true;
+			return this.getSchema() === SCHEMA.STREAMING_BLOB;
+		}
+		isIdempotencyToken() {
+			if (typeof this.traits === "number") return (this.traits & 4) === 4;
+			else if (typeof this.traits === "object") return !!this.traits.idempotencyToken;
+			return false;
+		}
+		getMergedTraits() {
+			return this.normalizedTraits ?? (this.normalizedTraits = {
+				...this.getOwnTraits(),
+				...this.getMemberTraits()
+			});
+		}
+		getMemberTraits() {
+			return NormalizedSchema.translateTraits(this.memberTraits);
+		}
+		getOwnTraits() {
+			return NormalizedSchema.translateTraits(this.traits);
+		}
+		getKeySchema() {
+			if (this.isDocumentSchema()) return this.memberFrom([SCHEMA.DOCUMENT, 0], "key");
+			if (!this.isMapSchema()) throw new Error(`@smithy/core/schema - cannot get key for non-map: ${this.getName(true)}`);
+			const schema = this.getSchema();
+			if (typeof schema === "number") return this.memberFrom([63 & schema, 0], "key");
+			return this.memberFrom([schema.keySchema, 0], "key");
+		}
+		getValueSchema() {
+			const schema = this.getSchema();
+			if (typeof schema === "number") {
+				if (this.isMapSchema()) return this.memberFrom([63 & schema, 0], "value");
+				else if (this.isListSchema()) return this.memberFrom([63 & schema, 0], "member");
+			}
+			if (schema && typeof schema === "object") {
+				if (this.isStructSchema()) throw new Error(`may not getValueSchema() on structure ${this.getName(true)}`);
+				const collection = schema;
+				if ("valueSchema" in collection) {
+					if (this.isMapSchema()) return this.memberFrom([collection.valueSchema, 0], "value");
+					else if (this.isListSchema()) return this.memberFrom([collection.valueSchema, 0], "member");
+				}
+			}
+			if (this.isDocumentSchema()) return this.memberFrom([SCHEMA.DOCUMENT, 0], "value");
+			throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`);
+		}
+		hasMemberSchema(member) {
+			if (this.isStructSchema()) return this.getSchema().memberNames.includes(member);
+			return false;
+		}
+		getMemberSchema(member) {
+			if (this.isStructSchema()) {
+				const struct$1 = this.getSchema();
+				if (!struct$1.memberNames.includes(member)) throw new Error(`@smithy/core/schema - ${this.getName(true)} has no member=${member}.`);
+				const i = struct$1.memberNames.indexOf(member);
+				const memberSchema = struct$1.memberList[i];
+				return this.memberFrom(Array.isArray(memberSchema) ? memberSchema : [memberSchema, 0], member);
+			}
+			if (this.isDocumentSchema()) return this.memberFrom([SCHEMA.DOCUMENT, 0], member);
+			throw new Error(`@smithy/core/schema - ${this.getName(true)} has no members.`);
+		}
+		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$1 = this.getSchema();
+			for (let i = 0; i < struct$1.memberNames.length; ++i) yield [struct$1.memberNames[i], this.memberFrom([struct$1.memberList[i], 0], struct$1.memberNames[i])];
+		}
+		memberFrom(memberSchema, memberName) {
+			if (memberSchema instanceof NormalizedSchema) return Object.assign(memberSchema, {
+				memberName,
+				_isMemberSchema: true
+			});
+			return new NormalizedSchema(memberSchema, memberName);
+		}
+		getSchemaName() {
+			const schema = this.getSchema();
+			if (typeof schema === "number") {
+				const _schema = 63 & schema;
+				const container = 192 & schema;
+				const type = Object.entries(SCHEMA).find(([, value]) => {
+					return value === _schema;
+				})?.[0] ?? "Unknown";
+				switch (container) {
+					case SCHEMA.MAP_MODIFIER: return `${type}Map`;
+					case SCHEMA.LIST_MODIFIER: return `${type}List`;
+					case 0: return type;
+				}
+			}
+			return "Unknown";
+		}
+	};
+	NormalizedSchema.symbol = Symbol.for("@smithy/nor");
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/index.js
+var schema_exports = /* @__PURE__ */ __export$6({
+	ErrorSchema: () => ErrorSchema,
+	ListSchema: () => ListSchema,
+	MapSchema: () => MapSchema,
+	NormalizedSchema: () => NormalizedSchema,
+	OperationSchema: () => OperationSchema,
+	SCHEMA: () => SCHEMA,
+	Schema: () => Schema,
+	SimpleSchema: () => SimpleSchema,
+	StructureSchema: () => StructureSchema,
+	TypeRegistry: () => TypeRegistry,
+	deref: () => deref,
+	deserializerMiddlewareOption: () => deserializerMiddlewareOption,
+	error: () => error,
+	getSchemaSerdePlugin: () => getSchemaSerdePlugin,
+	list: () => list,
+	map: () => map,
+	op: () => op,
+	serializerMiddlewareOption: () => serializerMiddlewareOption,
+	sim: () => sim,
+	struct: () => struct
+});
+var init_schema = __esm({ "../../node_modules/.pnpm/@smithy+core@3.11.1/node_modules/@smithy/core/dist-es/submodules/schema/index.js": (() => {
+	init_deref();
+	init_getSchemaSerdePlugin();
+	init_ListSchema();
+	init_MapSchema();
+	init_OperationSchema();
+	init_ErrorSchema();
+	init_NormalizedSchema();
+	init_Schema();
+	init_SimpleSchema();
+	init_StructureSchema();
+	init_sentinels();
+	init_TypeRegistry();
+}) });
+
+//#endregion
+export { NormalizedSchema, SCHEMA, TypeRegistry, __commonJS, __esm, __export$6 as __export, __require, __toCommonJS$6 as __toCommonJS, __toESM, deref, init_schema, require_dist_cjs, require_dist_cjs$1, require_dist_cjs$2, require_dist_cjs$3, require_dist_cjs$4, require_dist_cjs$5, schema_exports };