@resenty/widget 0.0.0

package/dist/chunks/schemas-B2StEWw-.js

@@ -0,0 +1,4326 @@
+const createClientConfig = (u) => ({
+	...u,
+	baseUrl: "https://api.resenty.com/__internal"
+}), jsonBodySerializer = { bodySerializer: (u) => JSON.stringify(u, (u, z) => typeof z == "bigint" ? z.toString() : z) };
+Object.entries({
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query"
+});
+const createSseClient = ({ onRequest: u, onSseError: z, onSseEvent: B, responseTransformer: V, responseValidator: H, sseDefaultRetryDelay: U, sseMaxRetryAttempts: W, sseMaxRetryDelay: G, sseSleepFn: K, url: q,...J }) => {
+	let Y, X = K ?? ((u) => new Promise((z) => setTimeout(z, u)));
+	return { stream: async function* () {
+		let K = U ?? 3e3, Z = 0, Q = J.signal ?? new AbortController().signal;
+		for (; !Q.aborted;) {
+			Z++;
+			let U = J.headers instanceof Headers ? J.headers : new Headers(J.headers);
+			Y !== void 0 && U.set("Last-Event-ID", Y);
+			try {
+				let z = {
+					redirect: "follow",
+					...J,
+					body: J.serializedBody,
+					headers: U,
+					signal: Q
+				}, W = new Request(q, z);
+				u && (W = await u(q, z));
+				let G = await (J.fetch ?? globalThis.fetch)(W);
+				if (!G.ok) throw Error(`SSE failed: ${G.status} ${G.statusText}`);
+				if (!G.body) throw Error("No body in SSE response");
+				let X = G.body.pipeThrough(new TextDecoderStream()).getReader(), Z = "", $ = () => {
+					try {
+						X.cancel();
+					} catch {}
+				};
+				Q.addEventListener("abort", $);
+				try {
+					for (;;) {
+						let { done: u, value: z } = await X.read();
+						if (u) break;
+						Z += z, Z = Z.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+						let U = Z.split("\n\n");
+						Z = U.pop() ?? "";
+						for (let u of U) {
+							let z = u.split("\n"), U = [], W;
+							for (let u of z) if (u.startsWith("data:")) U.push(u.replace(/^data:\s*/, ""));
+							else if (u.startsWith("event:")) W = u.replace(/^event:\s*/, "");
+							else if (u.startsWith("id:")) Y = u.replace(/^id:\s*/, "");
+							else if (u.startsWith("retry:")) {
+								let z = Number.parseInt(u.replace(/^retry:\s*/, ""), 10);
+								Number.isNaN(z) || (K = z);
+							}
+							let G, q = !1;
+							if (U.length) {
+								let u = U.join("\n");
+								try {
+									G = JSON.parse(u), q = !0;
+								} catch {
+									G = u;
+								}
+							}
+							q && (H && await H(G), V && (G = await V(G))), B?.({
+								data: G,
+								event: W,
+								id: Y,
+								retry: K
+							}), U.length && (yield G);
+						}
+					}
+				} finally {
+					Q.removeEventListener("abort", $), X.releaseLock();
+				}
+				break;
+			} catch (u) {
+				if (z?.(u), W !== void 0 && Z >= W) break;
+				await X(Math.min(K * 2 ** (Z - 1), G ?? 3e4));
+			}
+		}
+	}() };
+}, separatorArrayExplode = (u) => {
+	switch (u) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+}, separatorArrayNoExplode = (u) => {
+	switch (u) {
+		case "form": return ",";
+		case "pipeDelimited": return "|";
+		case "spaceDelimited": return "%20";
+		default: return ",";
+	}
+}, separatorObjectExplode = (u) => {
+	switch (u) {
+		case "label": return ".";
+		case "matrix": return ";";
+		case "simple": return ",";
+		default: return "&";
+	}
+}, serializeArrayParam = ({ allowReserved: u, explode: z, name: B, style: U, value: W }) => {
+	if (!z) {
+		let z = (u ? W : W.map((u) => encodeURIComponent(u))).join(separatorArrayNoExplode(U));
+		switch (U) {
+			case "label": return `.${z}`;
+			case "matrix": return `;${B}=${z}`;
+			case "simple": return z;
+			default: return `${B}=${z}`;
+		}
+	}
+	let K = separatorArrayExplode(U), q = W.map((z) => U === "label" || U === "simple" ? u ? z : encodeURIComponent(z) : serializePrimitiveParam({
+		allowReserved: u,
+		name: B,
+		value: z
+	})).join(K);
+	return U === "label" || U === "matrix" ? K + q : q;
+}, serializePrimitiveParam = ({ allowReserved: u, name: z, value: B }) => {
+	if (B == null) return "";
+	if (typeof B == "object") throw Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${z}=${u ? B : encodeURIComponent(B)}`;
+}, serializeObjectParam = ({ allowReserved: u, explode: z, name: B, style: V, value: H, valueOnly: W }) => {
+	if (H instanceof Date) return W ? H.toISOString() : `${B}=${H.toISOString()}`;
+	if (V !== "deepObject" && !z) {
+		let z = [];
+		Object.entries(H).forEach(([B, V]) => {
+			z = [
+				...z,
+				B,
+				u ? V : encodeURIComponent(V)
+			];
+		});
+		let U = z.join(",");
+		switch (V) {
+			case "form": return `${B}=${U}`;
+			case "label": return `.${U}`;
+			case "matrix": return `;${B}=${U}`;
+			default: return U;
+		}
+	}
+	let K = separatorObjectExplode(V), q = Object.entries(H).map(([z, H]) => serializePrimitiveParam({
+		allowReserved: u,
+		name: V === "deepObject" ? `${B}[${z}]` : z,
+		value: H
+	})).join(K);
+	return V === "label" || V === "matrix" ? K + q : q;
+}, PATH_PARAM_RE = /\{[^{}]+\}/g, defaultPathSerializer = ({ path: u, url: z }) => {
+	let B = z, V = z.match(PATH_PARAM_RE);
+	if (V) for (let z of V) {
+		let V = !1, H = z.substring(1, z.length - 1), U = "simple";
+		H.endsWith("*") && (V = !0, H = H.substring(0, H.length - 1)), H.startsWith(".") ? (H = H.substring(1), U = "label") : H.startsWith(";") && (H = H.substring(1), U = "matrix");
+		let q = u[H];
+		if (q == null) continue;
+		if (Array.isArray(q)) {
+			B = B.replace(z, serializeArrayParam({
+				explode: V,
+				name: H,
+				style: U,
+				value: q
+			}));
+			continue;
+		}
+		if (typeof q == "object") {
+			B = B.replace(z, serializeObjectParam({
+				explode: V,
+				name: H,
+				style: U,
+				value: q,
+				valueOnly: !0
+			}));
+			continue;
+		}
+		if (U === "matrix") {
+			B = B.replace(z, `;${serializePrimitiveParam({
+				name: H,
+				value: q
+			})}`);
+			continue;
+		}
+		let J = encodeURIComponent(U === "label" ? `.${q}` : q);
+		B = B.replace(z, J);
+	}
+	return B;
+}, getUrl = ({ baseUrl: u, path: z, query: B, querySerializer: V, url: H }) => {
+	let U = H.startsWith("/") ? H : `/${H}`, W = (u ?? "") + U;
+	z && (W = defaultPathSerializer({
+		path: z,
+		url: W
+	}));
+	let G = B ? V(B) : "";
+	return G.startsWith("?") && (G = G.substring(1)), G && (W += `?${G}`), W;
+};
+function getValidRequestBody(u) {
+	let z = u.body !== void 0;
+	if (z && u.bodySerializer) return "serializedBody" in u ? u.serializedBody !== void 0 && u.serializedBody !== "" ? u.serializedBody : null : u.body === "" ? null : u.body;
+	if (z) return u.body;
+}
+const getAuthToken = async (u, z) => {
+	let B = typeof z == "function" ? await z(u) : z;
+	if (B) return u.scheme === "bearer" ? `Bearer ${B}` : u.scheme === "basic" ? `Basic ${btoa(B)}` : B;
+}, createQuerySerializer = ({ parameters: u = {},...z } = {}) => (B) => {
+	let V = [];
+	if (B && typeof B == "object") for (let H in B) {
+		let U = B[H];
+		if (U == null) continue;
+		let q = u[H] || z;
+		if (Array.isArray(U)) {
+			let u = serializeArrayParam({
+				allowReserved: q.allowReserved,
+				explode: !0,
+				name: H,
+				style: "form",
+				value: U,
+				...q.array
+			});
+			u && V.push(u);
+		} else if (typeof U == "object") {
+			let u = serializeObjectParam({
+				allowReserved: q.allowReserved,
+				explode: !0,
+				name: H,
+				style: "deepObject",
+				value: U,
+				...q.object
+			});
+			u && V.push(u);
+		} else {
+			let u = serializePrimitiveParam({
+				allowReserved: q.allowReserved,
+				name: H,
+				value: U
+			});
+			u && V.push(u);
+		}
+	}
+	return V.join("&");
+}, getParseAs = (u) => {
+	if (!u) return "stream";
+	let z = u.split(";")[0]?.trim();
+	if (z) {
+		if (z.startsWith("application/json") || z.endsWith("+json")) return "json";
+		if (z === "multipart/form-data") return "formData";
+		if ([
+			"application/",
+			"audio/",
+			"image/",
+			"video/"
+		].some((u) => z.startsWith(u))) return "blob";
+		if (z.startsWith("text/")) return "text";
+	}
+};
+var checkForExistence = (u, z) => z ? !!(u.headers.has(z) || u.query?.[z] || u.headers.get("Cookie")?.includes(`${z}=`)) : !1;
+const setAuthParams = async ({ security: u,...z }) => {
+	for (let B of u) {
+		if (checkForExistence(z, B.name)) continue;
+		let u = await getAuthToken(B, z.auth);
+		if (!u) continue;
+		let V = B.name ?? "Authorization";
+		switch (B.in) {
+			case "query":
+				z.query ||= {}, z.query[V] = u;
+				break;
+			case "cookie":
+				z.headers.append("Cookie", `${V}=${u}`);
+				break;
+			case "header":
+			default:
+				z.headers.set(V, u);
+				break;
+		}
+	}
+}, buildUrl = (u) => getUrl({
+	baseUrl: u.baseUrl,
+	path: u.path,
+	query: u.query,
+	querySerializer: typeof u.querySerializer == "function" ? u.querySerializer : createQuerySerializer(u.querySerializer),
+	url: u.url
+}), mergeConfigs = (u, z) => {
+	let B = {
+		...u,
+		...z
+	};
+	return B.baseUrl?.endsWith("/") && (B.baseUrl = B.baseUrl.substring(0, B.baseUrl.length - 1)), B.headers = mergeHeaders(u.headers, z.headers), B;
+};
+var headersEntries = (u) => {
+	let z = [];
+	return u.forEach((u, B) => {
+		z.push([B, u]);
+	}), z;
+};
+const mergeHeaders = (...u) => {
+	let z = new Headers();
+	for (let B of u) {
+		if (!B) continue;
+		let u = B instanceof Headers ? headersEntries(B) : Object.entries(B);
+		for (let [B, V] of u) if (V === null) z.delete(B);
+		else if (Array.isArray(V)) for (let u of V) z.append(B, u);
+		else V !== void 0 && z.set(B, typeof V == "object" ? JSON.stringify(V) : V);
+	}
+	return z;
+};
+var Interceptors = class {
+	constructor() {
+		this.fns = [];
+	}
+	clear() {
+		this.fns = [];
+	}
+	eject(u) {
+		let z = this.getInterceptorIndex(u);
+		this.fns[z] && (this.fns[z] = null);
+	}
+	exists(u) {
+		let z = this.getInterceptorIndex(u);
+		return !!this.fns[z];
+	}
+	getInterceptorIndex(u) {
+		return typeof u == "number" ? this.fns[u] ? u : -1 : this.fns.indexOf(u);
+	}
+	update(u, z) {
+		let B = this.getInterceptorIndex(u);
+		return this.fns[B] ? (this.fns[B] = z, u) : !1;
+	}
+	use(u) {
+		return this.fns.push(u), this.fns.length - 1;
+	}
+};
+const createInterceptors = () => ({
+	error: new Interceptors(),
+	request: new Interceptors(),
+	response: new Interceptors()
+});
+var defaultQuerySerializer = createQuerySerializer({
+	allowReserved: !1,
+	array: {
+		explode: !0,
+		style: "form"
+	},
+	object: {
+		explode: !0,
+		style: "deepObject"
+	}
+}), defaultHeaders = { "Content-Type": "application/json" };
+const createConfig = (u = {}) => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...u
+}), client = ((u = {}) => {
+	let z = mergeConfigs(createConfig(), u), V = () => ({ ...z }), H = (u) => (z = mergeConfigs(z, u), V()), U = createInterceptors(), W = async (u) => {
+		let B = {
+			...z,
+			...u,
+			fetch: u.fetch ?? z.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(z.headers, u.headers),
+			serializedBody: void 0
+		};
+		return B.security && await setAuthParams({
+			...B,
+			security: B.security
+		}), B.requestValidator && await B.requestValidator(B), B.body !== void 0 && B.bodySerializer && (B.serializedBody = B.bodySerializer(B.body)), (B.body === void 0 || B.serializedBody === "") && B.headers.delete("Content-Type"), {
+			opts: B,
+			url: buildUrl(B)
+		};
+	}, G = async (u) => {
+		let { opts: z, url: B } = await W(u), V = {
+			redirect: "follow",
+			...z,
+			body: getValidRequestBody(z)
+		}, H = new Request(B, V);
+		for (let u of U.request.fns) u && (H = await u(H, z));
+		let G = z.fetch, K;
+		try {
+			K = await G(H);
+		} catch (u) {
+			let B = u;
+			for (let V of U.error.fns) V && (B = await V(u, void 0, H, z));
+			if (B ||= {}, z.throwOnError) throw B;
+			return z.responseStyle === "data" ? void 0 : {
+				error: B,
+				request: H,
+				response: void 0
+			};
+		}
+		for (let u of U.response.fns) u && (K = await u(K, H, z));
+		let q = {
+			request: H,
+			response: K
+		};
+		if (K.ok) {
+			let u = (z.parseAs === "auto" ? getParseAs(K.headers.get("Content-Type")) : z.parseAs) ?? "json";
+			if (K.status === 204 || K.headers.get("Content-Length") === "0") {
+				let B;
+				switch (u) {
+					case "arrayBuffer":
+					case "blob":
+					case "text":
+						B = await K[u]();
+						break;
+					case "formData":
+						B = new FormData();
+						break;
+					case "stream":
+						B = K.body;
+						break;
+					case "json":
+					default:
+						B = {};
+						break;
+				}
+				return z.responseStyle === "data" ? B : {
+					data: B,
+					...q
+				};
+			}
+			let B;
+			switch (u) {
+				case "arrayBuffer":
+				case "blob":
+				case "formData":
+				case "text":
+					B = await K[u]();
+					break;
+				case "json": {
+					let u = await K.text();
+					B = u ? JSON.parse(u) : {};
+					break;
+				}
+				case "stream": return z.responseStyle === "data" ? K.body : {
+					data: K.body,
+					...q
+				};
+			}
+			return u === "json" && (z.responseValidator && await z.responseValidator(B), z.responseTransformer && (B = await z.responseTransformer(B))), z.responseStyle === "data" ? B : {
+				data: B,
+				...q
+			};
+		}
+		let J = await K.text(), Y;
+		try {
+			Y = JSON.parse(J);
+		} catch {}
+		let Z = Y ?? J, Q = Z;
+		for (let u of U.error.fns) u && (Q = await u(Z, K, H, z));
+		if (Q ||= {}, z.throwOnError) throw Q;
+		return z.responseStyle === "data" ? void 0 : {
+			error: Q,
+			...q
+		};
+	}, K = (u) => (z) => G({
+		...z,
+		method: u
+	}), q = (u) => async (z) => {
+		let { opts: V, url: H } = await W(z);
+		return createSseClient({
+			...V,
+			body: V.body,
+			headers: V.headers,
+			method: u,
+			onRequest: async (u, z) => {
+				let B = new Request(u, z);
+				for (let u of U.request.fns) u && (B = await u(B, V));
+				return B;
+			},
+			serializedBody: getValidRequestBody(V),
+			url: H
+		});
+	};
+	return {
+		buildUrl,
+		connect: K("CONNECT"),
+		delete: K("DELETE"),
+		get: K("GET"),
+		getConfig: V,
+		head: K("HEAD"),
+		interceptors: U,
+		options: K("OPTIONS"),
+		patch: K("PATCH"),
+		post: K("POST"),
+		put: K("PUT"),
+		request: G,
+		setConfig: H,
+		sse: {
+			connect: q("CONNECT"),
+			delete: q("DELETE"),
+			get: q("GET"),
+			head: q("HEAD"),
+			options: q("OPTIONS"),
+			patch: q("PATCH"),
+			post: q("POST"),
+			put: q("PUT"),
+			trace: q("TRACE")
+		},
+		trace: K("TRACE")
+	};
+})(createClientConfig(createConfig({ baseUrl: "https://api.lcl-resenty.com/__internal" })));
+var HeyApiClient = class {
+	constructor(u) {
+		this.client = u?.client ?? client;
+	}
+}, HeyApiRegistry = class {
+	constructor() {
+		this.defaultKey = "default", this.instances = /* @__PURE__ */ new Map();
+	}
+	get(u) {
+		let z = this.instances.get(u ?? this.defaultKey);
+		if (!z) throw Error("No SDK client found. Create one with \"new Client()\" to fix this error.");
+		return z;
+	}
+	set(u, z) {
+		this.instances.set(z ?? this.defaultKey, u);
+	}
+}, Sessions = class extends HeyApiClient {
+	createSession(u) {
+		return (u?.client ?? this.client).post({
+			url: "/widget/sessions",
+			...u,
+			headers: {
+				"Content-Type": "application/json",
+				...u?.headers
+			}
+		});
+	}
+}, Messages = class extends HeyApiClient {
+	sendMessage(u) {
+		return (u.client ?? this.client).post({
+			url: "/widget/messages",
+			...u,
+			headers: {
+				"Content-Type": "application/json",
+				...u.headers
+			}
+		});
+	}
+	getMessages(u) {
+		return (u.client ?? this.client).get({
+			url: "/widget/messages/{threadId}",
+			...u
+		});
+	}
+}, Threads = class extends HeyApiClient {
+	getThreads(u) {
+		return (u?.client ?? this.client).get({
+			url: "/widget/threads",
+			...u
+		});
+	}
+}, Widget = class extends HeyApiClient {
+	get sessions() {
+		return this._sessions ??= new Sessions({ client: this.client });
+	}
+	get messages() {
+		return this._messages ??= new Messages({ client: this.client });
+	}
+	get threads() {
+		return this._threads ??= new Threads({ client: this.client });
+	}
+}, Client = class u extends HeyApiClient {
+	static #e = this.__registry = new HeyApiRegistry();
+	constructor(z) {
+		super(z), u.__registry.set(this, z?.key);
+	}
+	get widget() {
+		return this._widget ??= new Widget({ client: this.client });
+	}
+}, Subscribable = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+	}
+	subscribe(u) {
+		return this.listeners.add(u), this.onSubscribe(), () => {
+			this.listeners.delete(u), this.onUnsubscribe();
+		};
+	}
+	hasListeners() {
+		return this.listeners.size > 0;
+	}
+	onSubscribe() {}
+	onUnsubscribe() {}
+}, focusManager = new class extends Subscribable {
+	#e;
+	#t;
+	#n;
+	constructor() {
+		super(), this.#n = (u) => {
+			if (typeof window < "u" && window.addEventListener) {
+				let z = () => u();
+				return window.addEventListener("visibilitychange", z, !1), () => {
+					window.removeEventListener("visibilitychange", z);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		this.#t || this.setEventListener(this.#n);
+	}
+	onUnsubscribe() {
+		this.hasListeners() || (this.#t?.(), this.#t = void 0);
+	}
+	setEventListener(u) {
+		this.#n = u, this.#t?.(), this.#t = u((u) => {
+			typeof u == "boolean" ? this.setFocused(u) : this.onFocus();
+		});
+	}
+	setFocused(u) {
+		this.#e !== u && (this.#e = u, this.onFocus());
+	}
+	onFocus() {
+		let u = this.isFocused();
+		this.listeners.forEach((z) => {
+			z(u);
+		});
+	}
+	isFocused() {
+		return typeof this.#e == "boolean" ? this.#e : globalThis.document?.visibilityState !== "hidden";
+	}
+}(), defaultTimeoutProvider = {
+	setTimeout: (u, z) => setTimeout(u, z),
+	clearTimeout: (u) => clearTimeout(u),
+	setInterval: (u, z) => setInterval(u, z),
+	clearInterval: (u) => clearInterval(u)
+}, timeoutManager = new class {
+	#e = defaultTimeoutProvider;
+	#t = !1;
+	setTimeoutProvider(u) {
+		process.env.NODE_ENV !== "production" && this.#t && u !== this.#e && console.error("[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.", {
+			previous: this.#e,
+			provider: u
+		}), this.#e = u, process.env.NODE_ENV !== "production" && (this.#t = !1);
+	}
+	setTimeout(u, z) {
+		return process.env.NODE_ENV !== "production" && (this.#t = !0), this.#e.setTimeout(u, z);
+	}
+	clearTimeout(u) {
+		this.#e.clearTimeout(u);
+	}
+	setInterval(u, z) {
+		return process.env.NODE_ENV !== "production" && (this.#t = !0), this.#e.setInterval(u, z);
+	}
+	clearInterval(u) {
+		this.#e.clearInterval(u);
+	}
+}();
+function systemSetTimeoutZero(u) {
+	setTimeout(u, 0);
+}
+var isServer = typeof window > "u" || "Deno" in globalThis;
+function noop() {}
+function functionalUpdate(u, z) {
+	return typeof u == "function" ? u(z) : u;
+}
+function isValidTimeout(u) {
+	return typeof u == "number" && u >= 0 && u !== Infinity;
+}
+function timeUntilStale(u, z) {
+	return Math.max(u + (z || 0) - Date.now(), 0);
+}
+function resolveStaleTime(u, z) {
+	return typeof u == "function" ? u(z) : u;
+}
+function resolveQueryBoolean(u, z) {
+	return typeof u == "function" ? u(z) : u;
+}
+function matchQuery(u, z) {
+	let { type: B = "all", exact: V, fetchStatus: H, predicate: U, queryKey: W, stale: G } = u;
+	if (W) {
+		if (V) {
+			if (z.queryHash !== hashQueryKeyByOptions(W, z.options)) return !1;
+		} else if (!partialMatchKey(z.queryKey, W)) return !1;
+	}
+	if (B !== "all") {
+		let u = z.isActive();
+		if (B === "active" && !u || B === "inactive" && u) return !1;
+	}
+	return !(typeof G == "boolean" && z.isStale() !== G || H && H !== z.state.fetchStatus || U && !U(z));
+}
+function matchMutation(u, z) {
+	let { exact: B, status: V, predicate: H, mutationKey: U } = u;
+	if (U) {
+		if (!z.options.mutationKey) return !1;
+		if (B) {
+			if (hashKey(z.options.mutationKey) !== hashKey(U)) return !1;
+		} else if (!partialMatchKey(z.options.mutationKey, U)) return !1;
+	}
+	return !(V && z.state.status !== V || H && !H(z));
+}
+function hashQueryKeyByOptions(u, z) {
+	return (z?.queryKeyHashFn || hashKey)(u);
+}
+function hashKey(u) {
+	return JSON.stringify(u, (u, z) => isPlainObject$1(z) ? Object.keys(z).sort().reduce((u, B) => (u[B] = z[B], u), {}) : z);
+}
+function partialMatchKey(u, z) {
+	return u === z ? !0 : typeof u == typeof z && u && z && typeof u == "object" && typeof z == "object" ? Object.keys(z).every((B) => partialMatchKey(u[B], z[B])) : !1;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(u, z, B = 0) {
+	if (u === z) return u;
+	if (B > 500) return z;
+	let V = isPlainArray(u) && isPlainArray(z);
+	if (!V && !(isPlainObject$1(u) && isPlainObject$1(z))) return z;
+	let H = (V ? u : Object.keys(u)).length, U = V ? z : Object.keys(z), W = U.length, G = V ? Array(W) : {}, K = 0;
+	for (let q = 0; q < W; q++) {
+		let W = V ? q : U[q], J = u[W], Y = z[W];
+		if (J === Y) {
+			G[W] = J, (V ? q < H : hasOwn.call(u, W)) && K++;
+			continue;
+		}
+		if (J === null || Y === null || typeof J != "object" || typeof Y != "object") {
+			G[W] = Y;
+			continue;
+		}
+		let X = replaceEqualDeep(J, Y, B + 1);
+		G[W] = X, X === J && K++;
+	}
+	return H === W && K === H ? u : G;
+}
+function shallowEqualObjects(u, z) {
+	if (!z || Object.keys(u).length !== Object.keys(z).length) return !1;
+	for (let B in u) if (u[B] !== z[B]) return !1;
+	return !0;
+}
+function isPlainArray(u) {
+	return Array.isArray(u) && u.length === Object.keys(u).length;
+}
+function isPlainObject$1(u) {
+	if (!hasObjectPrototype(u)) return !1;
+	let z = u.constructor;
+	if (z === void 0) return !0;
+	let B = z.prototype;
+	return !(!hasObjectPrototype(B) || !B.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(u) !== Object.prototype);
+}
+function hasObjectPrototype(u) {
+	return Object.prototype.toString.call(u) === "[object Object]";
+}
+function sleep(u) {
+	return new Promise((z) => {
+		timeoutManager.setTimeout(z, u);
+	});
+}
+function replaceData(u, z, B) {
+	if (typeof B.structuralSharing == "function") return B.structuralSharing(u, z);
+	if (B.structuralSharing !== !1) {
+		if (process.env.NODE_ENV !== "production") try {
+			return replaceEqualDeep(u, z);
+		} catch (u) {
+			throw console.error(`Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${B.queryHash}]: ${u}`), u;
+		}
+		return replaceEqualDeep(u, z);
+	}
+	return z;
+}
+function addToEnd(u, z, B = 0) {
+	let V = [...u, z];
+	return B && V.length > B ? V.slice(1) : V;
+}
+function addToStart(u, z, B = 0) {
+	let V = [z, ...u];
+	return B && V.length > B ? V.slice(0, -1) : V;
+}
+var skipToken = /* @__PURE__ */ Symbol();
+function ensureQueryFn(u, z) {
+	return process.env.NODE_ENV !== "production" && u.queryFn === skipToken && console.error(`Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${u.queryHash}'`), !u.queryFn && z?.initialPromise ? () => z.initialPromise : !u.queryFn || u.queryFn === skipToken ? () => Promise.reject(/* @__PURE__ */ Error(`Missing queryFn: '${u.queryHash}'`)) : u.queryFn;
+}
+function shouldThrowError(u, z) {
+	return typeof u == "function" ? u(...z) : !!u;
+}
+function addConsumeAwareSignal(u, z, B) {
+	let V = !1, H;
+	return Object.defineProperty(u, "signal", {
+		enumerable: !0,
+		get: () => (H ??= z(), V ? H : (V = !0, H.aborted ? B() : H.addEventListener("abort", B, { once: !0 }), H))
+	}), u;
+}
+var environmentManager = /* @__PURE__ */ (() => {
+	let u = () => isServer;
+	return {
+		isServer() {
+			return u();
+		},
+		setIsServer(z) {
+			u = z;
+		}
+	};
+})();
+function pendingThenable() {
+	let u, z, B = new Promise((B, V) => {
+		u = B, z = V;
+	});
+	B.status = "pending", B.catch(() => {});
+	function V(u) {
+		Object.assign(B, u), delete B.resolve, delete B.reject;
+	}
+	return B.resolve = (z) => {
+		V({
+			status: "fulfilled",
+			value: z
+		}), u(z);
+	}, B.reject = (u) => {
+		V({
+			status: "rejected",
+			reason: u
+		}), z(u);
+	}, B;
+}
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+	let u = [], z = 0, B = (u) => {
+		u();
+	}, V = (u) => {
+		u();
+	}, H = defaultScheduler, U = (V) => {
+		z ? u.push(V) : H(() => {
+			B(V);
+		});
+	}, W = () => {
+		let z = u;
+		u = [], z.length && H(() => {
+			V(() => {
+				z.forEach((u) => {
+					B(u);
+				});
+			});
+		});
+	};
+	return {
+		batch: (u) => {
+			let B;
+			z++;
+			try {
+				B = u();
+			} finally {
+				z--, z || W();
+			}
+			return B;
+		},
+		batchCalls: (u) => (...z) => {
+			U(() => {
+				u(...z);
+			});
+		},
+		schedule: U,
+		setNotifyFunction: (u) => {
+			B = u;
+		},
+		setBatchNotifyFunction: (u) => {
+			V = u;
+		},
+		setScheduler: (u) => {
+			H = u;
+		}
+	};
+}
+var notifyManager = createNotifyManager(), onlineManager = new class extends Subscribable {
+	#e = !0;
+	#t;
+	#n;
+	constructor() {
+		super(), this.#n = (u) => {
+			if (typeof window < "u" && window.addEventListener) {
+				let z = () => u(!0), B = () => u(!1);
+				return window.addEventListener("online", z, !1), window.addEventListener("offline", B, !1), () => {
+					window.removeEventListener("online", z), window.removeEventListener("offline", B);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		this.#t || this.setEventListener(this.#n);
+	}
+	onUnsubscribe() {
+		this.hasListeners() || (this.#t?.(), this.#t = void 0);
+	}
+	setEventListener(u) {
+		this.#n = u, this.#t?.(), this.#t = u(this.setOnline.bind(this));
+	}
+	setOnline(u) {
+		this.#e !== u && (this.#e = u, this.listeners.forEach((z) => {
+			z(u);
+		}));
+	}
+	isOnline() {
+		return this.#e;
+	}
+}();
+function defaultRetryDelay(u) {
+	return Math.min(1e3 * 2 ** u, 3e4);
+}
+function canFetch(u) {
+	return (u ?? "online") === "online" ? onlineManager.isOnline() : !0;
+}
+var CancelledError = class extends Error {
+	constructor(u) {
+		super("CancelledError"), this.revert = u?.revert, this.silent = u?.silent;
+	}
+};
+function createRetryer(u) {
+	let z = !1, B = 0, V, H = pendingThenable(), U = () => H.status !== "pending", W = (z) => {
+		if (!U()) {
+			let B = new CancelledError(z);
+			X(B), u.onCancel?.(B);
+		}
+	}, G = () => {
+		z = !0;
+	}, K = () => {
+		z = !1;
+	}, q = () => focusManager.isFocused() && (u.networkMode === "always" || onlineManager.isOnline()) && u.canRun(), J = () => canFetch(u.networkMode) && u.canRun(), Y = (u) => {
+		U() || (V?.(), H.resolve(u));
+	}, X = (u) => {
+		U() || (V?.(), H.reject(u));
+	}, Z = () => new Promise((z) => {
+		V = (u) => {
+			(U() || q()) && z(u);
+		}, u.onPause?.();
+	}).then(() => {
+		V = void 0, U() || u.onContinue?.();
+	}), Q = () => {
+		if (U()) return;
+		let V, H = B === 0 ? u.initialPromise : void 0;
+		try {
+			V = H ?? u.fn();
+		} catch (u) {
+			V = Promise.reject(u);
+		}
+		Promise.resolve(V).then(Y).catch((V) => {
+			if (U()) return;
+			let H = u.retry ?? (environmentManager.isServer() ? 0 : 3), W = u.retryDelay ?? defaultRetryDelay, G = typeof W == "function" ? W(B, V) : W, K = H === !0 || typeof H == "number" && B < H || typeof H == "function" && H(B, V);
+			if (z || !K) {
+				X(V);
+				return;
+			}
+			B++, u.onFail?.(B, V), sleep(G).then(() => q() ? void 0 : Z()).then(() => {
+				z ? X(V) : Q();
+			});
+		});
+	};
+	return {
+		promise: H,
+		status: () => H.status,
+		cancel: W,
+		continue: () => (V?.(), H),
+		cancelRetry: G,
+		continueRetry: K,
+		canStart: J,
+		start: () => (J() ? Q() : Z().then(Q), H)
+	};
+}
+var Removable = class {
+	#e;
+	destroy() {
+		this.clearGcTimeout();
+	}
+	scheduleGc() {
+		this.clearGcTimeout(), isValidTimeout(this.gcTime) && (this.#e = timeoutManager.setTimeout(() => {
+			this.optionalRemove();
+		}, this.gcTime));
+	}
+	updateGcTime(u) {
+		this.gcTime = Math.max(this.gcTime || 0, u ?? (environmentManager.isServer() ? Infinity : 300 * 1e3));
+	}
+	clearGcTimeout() {
+		this.#e !== void 0 && (timeoutManager.clearTimeout(this.#e), this.#e = void 0);
+	}
+};
+function infiniteQueryBehavior(u) {
+	return { onFetch: (z, B) => {
+		let V = z.options, H = z.fetchOptions?.meta?.fetchMore?.direction, U = z.state.data?.pages || [], W = z.state.data?.pageParams || [], G = {
+			pages: [],
+			pageParams: []
+		}, K = 0, q = async () => {
+			let B = !1, q = (u) => {
+				addConsumeAwareSignal(u, () => z.signal, () => B = !0);
+			}, J = ensureQueryFn(z.options, z.fetchOptions), Y = async (u, V, H) => {
+				if (B) return Promise.reject(z.signal.reason);
+				if (V == null && u.pages.length) return Promise.resolve(u);
+				let U = await J((() => {
+					let u = {
+						client: z.client,
+						queryKey: z.queryKey,
+						pageParam: V,
+						direction: H ? "backward" : "forward",
+						meta: z.options.meta
+					};
+					return q(u), u;
+				})()), { maxPages: W } = z.options, G = H ? addToStart : addToEnd;
+				return {
+					pages: G(u.pages, U, W),
+					pageParams: G(u.pageParams, V, W)
+				};
+			};
+			if (H && U.length) {
+				let u = H === "backward", z = u ? getPreviousPageParam : getNextPageParam, B = {
+					pages: U,
+					pageParams: W
+				};
+				G = await Y(B, z(V, B), u);
+			} else {
+				let z = u ?? U.length;
+				do {
+					let u = K === 0 ? W[0] ?? V.initialPageParam : getNextPageParam(V, G);
+					if (K > 0 && u == null) break;
+					G = await Y(G, u), K++;
+				} while (K < z);
+			}
+			return G;
+		};
+		z.options.persister ? z.fetchFn = () => z.options.persister?.(q, {
+			client: z.client,
+			queryKey: z.queryKey,
+			meta: z.options.meta,
+			signal: z.signal
+		}, B) : z.fetchFn = q;
+	} };
+}
+function getNextPageParam(u, { pages: z, pageParams: B }) {
+	let V = z.length - 1;
+	return z.length > 0 ? u.getNextPageParam(z[V], z, B[V], B) : void 0;
+}
+function getPreviousPageParam(u, { pages: z, pageParams: B }) {
+	return z.length > 0 ? u.getPreviousPageParam?.(z[0], z, B[0], B) : void 0;
+}
+var Query = class extends Removable {
+	#e;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s;
+	constructor(u) {
+		super(), this.#s = !1, this.#o = u.defaultOptions, this.setOptions(u.options), this.observers = [], this.#i = u.client, this.#r = this.#i.getQueryCache(), this.queryKey = u.queryKey, this.queryHash = u.queryHash, this.#t = getDefaultState$1(this.options), this.state = u.state ?? this.#t, this.scheduleGc();
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	get queryType() {
+		return this.#e;
+	}
+	get promise() {
+		return this.#a?.promise;
+	}
+	setOptions(u) {
+		if (this.options = {
+			...this.#o,
+			...u
+		}, u?._type && (this.#e = u._type), this.updateGcTime(this.options.gcTime), this.state && this.state.data === void 0) {
+			let u = getDefaultState$1(this.options);
+			u.data !== void 0 && (this.setState(successState(u.data, u.dataUpdatedAt)), this.#t = u);
+		}
+	}
+	optionalRemove() {
+		!this.observers.length && this.state.fetchStatus === "idle" && this.#r.remove(this);
+	}
+	setData(u, z) {
+		let B = replaceData(this.state.data, u, this.options);
+		return this.#l({
+			data: B,
+			type: "success",
+			dataUpdatedAt: z?.updatedAt,
+			manual: z?.manual
+		}), B;
+	}
+	setState(u) {
+		this.#l({
+			type: "setState",
+			state: u
+		});
+	}
+	cancel(u) {
+		let z = this.#a?.promise;
+		return this.#a?.cancel(u), z ? z.then(noop).catch(noop) : Promise.resolve();
+	}
+	destroy() {
+		super.destroy(), this.cancel({ silent: !0 });
+	}
+	get resetState() {
+		return this.#t;
+	}
+	reset() {
+		this.destroy(), this.setState(this.resetState);
+	}
+	isActive() {
+		return this.observers.some((u) => resolveQueryBoolean(u.options.enabled, this) !== !1);
+	}
+	isDisabled() {
+		return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === skipToken || !this.isFetched();
+	}
+	isFetched() {
+		return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
+	}
+	isStatic() {
+		return this.getObserversCount() > 0 ? this.observers.some((u) => resolveStaleTime(u.options.staleTime, this) === "static") : !1;
+	}
+	isStale() {
+		return this.getObserversCount() > 0 ? this.observers.some((u) => u.getCurrentResult().isStale) : this.state.data === void 0 || this.state.isInvalidated;
+	}
+	isStaleByTime(u = 0) {
+		return this.state.data === void 0 ? !0 : u === "static" ? !1 : this.state.isInvalidated ? !0 : !timeUntilStale(this.state.dataUpdatedAt, u);
+	}
+	onFocus() {
+		this.observers.find((u) => u.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: !1 }), this.#a?.continue();
+	}
+	onOnline() {
+		this.observers.find((u) => u.shouldFetchOnReconnect())?.refetch({ cancelRefetch: !1 }), this.#a?.continue();
+	}
+	addObserver(u) {
+		this.observers.includes(u) || (this.observers.push(u), this.clearGcTimeout(), this.#r.notify({
+			type: "observerAdded",
+			query: this,
+			observer: u
+		}));
+	}
+	removeObserver(u) {
+		this.observers.includes(u) && (this.observers = this.observers.filter((z) => z !== u), this.observers.length || (this.#a && (this.#s || this.#c() ? this.#a.cancel({ revert: !0 }) : this.#a.cancelRetry()), this.scheduleGc()), this.#r.notify({
+			type: "observerRemoved",
+			query: this,
+			observer: u
+		}));
+	}
+	getObserversCount() {
+		return this.observers.length;
+	}
+	#c() {
+		return this.state.fetchStatus === "paused" && this.state.status === "pending";
+	}
+	invalidate() {
+		this.state.isInvalidated || this.#l({ type: "invalidate" });
+	}
+	async fetch(u, z) {
+		if (this.state.fetchStatus !== "idle" && this.#a?.status() !== "rejected") {
+			if (this.state.data !== void 0 && z?.cancelRefetch) this.cancel({ silent: !0 });
+			else if (this.#a) return this.#a.continueRetry(), this.#a.promise;
+		}
+		if (u && this.setOptions(u), !this.options.queryFn) {
+			let u = this.observers.find((u) => u.options.queryFn);
+			u && this.setOptions(u.options);
+		}
+		process.env.NODE_ENV !== "production" && (Array.isArray(this.options.queryKey) || console.error("As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']"));
+		let B = new AbortController(), V = (u) => {
+			Object.defineProperty(u, "signal", {
+				enumerable: !0,
+				get: () => (this.#s = !0, B.signal)
+			});
+		}, H = () => {
+			let u = ensureQueryFn(this.options, z), B = (() => {
+				let u = {
+					client: this.#i,
+					queryKey: this.queryKey,
+					meta: this.meta
+				};
+				return V(u), u;
+			})();
+			return this.#s = !1, this.options.persister ? this.options.persister(u, B, this) : u(B);
+		}, U = (() => {
+			let u = {
+				fetchOptions: z,
+				options: this.options,
+				queryKey: this.queryKey,
+				client: this.#i,
+				state: this.state,
+				fetchFn: H
+			};
+			return V(u), u;
+		})();
+		(this.#e === "infinite" ? infiniteQueryBehavior(this.options.pages) : this.options.behavior)?.onFetch(U, this), this.#n = this.state, (this.state.fetchStatus === "idle" || this.state.fetchMeta !== U.fetchOptions?.meta) && this.#l({
+			type: "fetch",
+			meta: U.fetchOptions?.meta
+		}), this.#a = createRetryer({
+			initialPromise: z?.initialPromise,
+			fn: U.fetchFn,
+			onCancel: (u) => {
+				u instanceof CancelledError && u.revert && this.setState({
+					...this.#n,
+					fetchStatus: "idle"
+				}), B.abort();
+			},
+			onFail: (u, z) => {
+				this.#l({
+					type: "failed",
+					failureCount: u,
+					error: z
+				});
+			},
+			onPause: () => {
+				this.#l({ type: "pause" });
+			},
+			onContinue: () => {
+				this.#l({ type: "continue" });
+			},
+			retry: U.options.retry,
+			retryDelay: U.options.retryDelay,
+			networkMode: U.options.networkMode,
+			canRun: () => !0
+		});
+		try {
+			let u = await this.#a.start();
+			if (u === void 0) throw process.env.NODE_ENV !== "production" && console.error(`Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`), Error(`${this.queryHash} data is undefined`);
+			return this.setData(u), this.#r.config.onSuccess?.(u, this), this.#r.config.onSettled?.(u, this.state.error, this), u;
+		} catch (u) {
+			if (u instanceof CancelledError) {
+				if (u.silent) return this.#a.promise;
+				if (u.revert) {
+					if (this.state.data === void 0) throw u;
+					return this.state.data;
+				}
+			}
+			throw this.#l({
+				type: "error",
+				error: u
+			}), this.#r.config.onError?.(u, this), this.#r.config.onSettled?.(this.state.data, u, this), u;
+		} finally {
+			this.scheduleGc();
+		}
+	}
+	#l(u) {
+		this.state = ((z) => {
+			switch (u.type) {
+				case "failed": return {
+					...z,
+					fetchFailureCount: u.failureCount,
+					fetchFailureReason: u.error
+				};
+				case "pause": return {
+					...z,
+					fetchStatus: "paused"
+				};
+				case "continue": return {
+					...z,
+					fetchStatus: "fetching"
+				};
+				case "fetch": return {
+					...z,
+					...fetchState(z.data, this.options),
+					fetchMeta: u.meta ?? null
+				};
+				case "success":
+					let B = {
+						...z,
+						...successState(u.data, u.dataUpdatedAt),
+						dataUpdateCount: z.dataUpdateCount + 1,
+						...!u.manual && {
+							fetchStatus: "idle",
+							fetchFailureCount: 0,
+							fetchFailureReason: null
+						}
+					};
+					return this.#n = u.manual ? B : void 0, B;
+				case "error":
+					let V = u.error;
+					return {
+						...z,
+						error: V,
+						errorUpdateCount: z.errorUpdateCount + 1,
+						errorUpdatedAt: Date.now(),
+						fetchFailureCount: z.fetchFailureCount + 1,
+						fetchFailureReason: V,
+						fetchStatus: "idle",
+						status: "error",
+						isInvalidated: !0
+					};
+				case "invalidate": return {
+					...z,
+					isInvalidated: !0
+				};
+				case "setState": return {
+					...z,
+					...u.state
+				};
+			}
+		})(this.state), notifyManager.batch(() => {
+			this.observers.forEach((u) => {
+				u.onQueryUpdate();
+			}), this.#r.notify({
+				query: this,
+				type: "updated",
+				action: u
+			});
+		});
+	}
+};
+function fetchState(u, z) {
+	return {
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchStatus: canFetch(z.networkMode) ? "fetching" : "paused",
+		...u === void 0 && {
+			error: null,
+			status: "pending"
+		}
+	};
+}
+function successState(u, z) {
+	return {
+		data: u,
+		dataUpdatedAt: z ?? Date.now(),
+		error: null,
+		isInvalidated: !1,
+		status: "success"
+	};
+}
+function getDefaultState$1(u) {
+	let z = typeof u.initialData == "function" ? u.initialData() : u.initialData, B = z !== void 0, V = B ? typeof u.initialDataUpdatedAt == "function" ? u.initialDataUpdatedAt() : u.initialDataUpdatedAt : 0;
+	return {
+		data: z,
+		dataUpdateCount: 0,
+		dataUpdatedAt: B ? V ?? Date.now() : 0,
+		error: null,
+		errorUpdateCount: 0,
+		errorUpdatedAt: 0,
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchMeta: null,
+		isInvalidated: !1,
+		status: B ? "success" : "pending",
+		fetchStatus: "idle"
+	};
+}
+var Mutation = class extends Removable {
+	#e;
+	#t;
+	#n;
+	#r;
+	constructor(u) {
+		super(), this.#e = u.client, this.mutationId = u.mutationId, this.#n = u.mutationCache, this.#t = [], this.state = u.state || getDefaultState(), this.setOptions(u.options), this.scheduleGc();
+	}
+	setOptions(u) {
+		this.options = u, this.updateGcTime(this.options.gcTime);
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	addObserver(u) {
+		this.#t.includes(u) || (this.#t.push(u), this.clearGcTimeout(), this.#n.notify({
+			type: "observerAdded",
+			mutation: this,
+			observer: u
+		}));
+	}
+	removeObserver(u) {
+		this.#t = this.#t.filter((z) => z !== u), this.scheduleGc(), this.#n.notify({
+			type: "observerRemoved",
+			mutation: this,
+			observer: u
+		});
+	}
+	optionalRemove() {
+		this.#t.length || (this.state.status === "pending" ? this.scheduleGc() : this.#n.remove(this));
+	}
+	continue() {
+		return this.#r?.continue() ?? this.execute(this.state.variables);
+	}
+	async execute(u) {
+		let z = () => {
+			this.#i({ type: "continue" });
+		}, B = {
+			client: this.#e,
+			meta: this.options.meta,
+			mutationKey: this.options.mutationKey
+		};
+		this.#r = createRetryer({
+			fn: () => this.options.mutationFn ? this.options.mutationFn(u, B) : Promise.reject(/* @__PURE__ */ Error("No mutationFn found")),
+			onFail: (u, z) => {
+				this.#i({
+					type: "failed",
+					failureCount: u,
+					error: z
+				});
+			},
+			onPause: () => {
+				this.#i({ type: "pause" });
+			},
+			onContinue: z,
+			retry: this.options.retry ?? 0,
+			retryDelay: this.options.retryDelay,
+			networkMode: this.options.networkMode,
+			canRun: () => this.#n.canRun(this)
+		});
+		let V = this.state.status === "pending", H = !this.#r.canStart();
+		try {
+			if (V) z();
+			else {
+				this.#i({
+					type: "pending",
+					variables: u,
+					isPaused: H
+				}), this.#n.config.onMutate && await this.#n.config.onMutate(u, this, B);
+				let z = await this.options.onMutate?.(u, B);
+				z !== this.state.context && this.#i({
+					type: "pending",
+					context: z,
+					variables: u,
+					isPaused: H
+				});
+			}
+			let U = await this.#r.start();
+			return await this.#n.config.onSuccess?.(U, u, this.state.context, this, B), await this.options.onSuccess?.(U, u, this.state.context, B), await this.#n.config.onSettled?.(U, null, this.state.variables, this.state.context, this, B), await this.options.onSettled?.(U, null, u, this.state.context, B), this.#i({
+				type: "success",
+				data: U
+			}), U;
+		} catch (z) {
+			try {
+				await this.#n.config.onError?.(z, u, this.state.context, this, B);
+			} catch (u) {
+				Promise.reject(u);
+			}
+			try {
+				await this.options.onError?.(z, u, this.state.context, B);
+			} catch (u) {
+				Promise.reject(u);
+			}
+			try {
+				await this.#n.config.onSettled?.(void 0, z, this.state.variables, this.state.context, this, B);
+			} catch (u) {
+				Promise.reject(u);
+			}
+			try {
+				await this.options.onSettled?.(void 0, z, u, this.state.context, B);
+			} catch (u) {
+				Promise.reject(u);
+			}
+			throw this.#i({
+				type: "error",
+				error: z
+			}), z;
+		} finally {
+			this.#n.runNext(this);
+		}
+	}
+	#i(u) {
+		this.state = ((z) => {
+			switch (u.type) {
+				case "failed": return {
+					...z,
+					failureCount: u.failureCount,
+					failureReason: u.error
+				};
+				case "pause": return {
+					...z,
+					isPaused: !0
+				};
+				case "continue": return {
+					...z,
+					isPaused: !1
+				};
+				case "pending": return {
+					...z,
+					context: u.context,
+					data: void 0,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					isPaused: u.isPaused,
+					status: "pending",
+					variables: u.variables,
+					submittedAt: Date.now()
+				};
+				case "success": return {
+					...z,
+					data: u.data,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					status: "success",
+					isPaused: !1
+				};
+				case "error": return {
+					...z,
+					data: void 0,
+					error: u.error,
+					failureCount: z.failureCount + 1,
+					failureReason: u.error,
+					isPaused: !1,
+					status: "error"
+				};
+			}
+		})(this.state), notifyManager.batch(() => {
+			this.#t.forEach((z) => {
+				z.onMutationUpdate(u);
+			}), this.#n.notify({
+				mutation: this,
+				type: "updated",
+				action: u
+			});
+		});
+	}
+};
+function getDefaultState() {
+	return {
+		context: void 0,
+		data: void 0,
+		error: null,
+		failureCount: 0,
+		failureReason: null,
+		isPaused: !1,
+		status: "idle",
+		variables: void 0,
+		submittedAt: 0
+	};
+}
+var _a$1;
+function $constructor(u, z, B) {
+	function V(B, V) {
+		if (B._zod || Object.defineProperty(B, "_zod", {
+			value: {
+				def: V,
+				constr: W,
+				traits: /* @__PURE__ */ new Set()
+			},
+			enumerable: !1
+		}), B._zod.traits.has(u)) return;
+		B._zod.traits.add(u), z(B, V);
+		let H = W.prototype, U = Object.keys(H);
+		for (let u = 0; u < U.length; u++) {
+			let z = U[u];
+			z in B || (B[z] = H[z].bind(B));
+		}
+	}
+	let H = B?.Parent ?? Object;
+	class U extends H {}
+	Object.defineProperty(U, "name", { value: u });
+	function W(u) {
+		var z;
+		let H = B?.Parent ? new U() : this;
+		V(H, u), (z = H._zod).deferred ?? (z.deferred = []);
+		for (let u of H._zod.deferred) u();
+		return H;
+	}
+	return Object.defineProperty(W, "init", { value: V }), Object.defineProperty(W, Symbol.hasInstance, { value: (z) => B?.Parent && z instanceof B.Parent ? !0 : z?._zod?.traits?.has(u) }), Object.defineProperty(W, "name", { value: u }), W;
+}
+var $ZodAsyncError = class extends Error {
+	constructor() {
+		super("Encountered Promise during synchronous parse. Use .parseAsync() instead.");
+	}
+}, $ZodEncodeError = class extends Error {
+	constructor(u) {
+		super(`Encountered unidirectional transform during encode: ${u}`), this.name = "ZodEncodeError";
+	}
+};
+(_a$1 = globalThis).__zod_globalConfig ?? (_a$1.__zod_globalConfig = {});
+const globalConfig = globalThis.__zod_globalConfig;
+function config(u) {
+	return u && Object.assign(globalConfig, u), globalConfig;
+}
+function getEnumValues(u) {
+	let z = Object.values(u).filter((u) => typeof u == "number");
+	return Object.entries(u).filter(([u, B]) => z.indexOf(+u) === -1).map(([u, z]) => z);
+}
+function jsonStringifyReplacer(u, z) {
+	return typeof z == "bigint" ? z.toString() : z;
+}
+function cached(u) {
+	return { get value() {
+		{
+			let z = u();
+			return Object.defineProperty(this, "value", { value: z }), z;
+		}
+		throw Error("cached value already set");
+	} };
+}
+function nullish(u) {
+	return u == null;
+}
+function cleanRegex(u) {
+	let z = u.startsWith("^") ? 1 : 0, B = u.endsWith("$") ? u.length - 1 : u.length;
+	return u.slice(z, B);
+}
+var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
+function defineLazy(u, z, B) {
+	let V;
+	Object.defineProperty(u, z, {
+		get() {
+			if (V !== EVALUATING) return V === void 0 && (V = EVALUATING, V = B()), V;
+		},
+		set(B) {
+			Object.defineProperty(u, z, { value: B });
+		},
+		configurable: !0
+	});
+}
+function assignProp(u, z, B) {
+	Object.defineProperty(u, z, {
+		value: B,
+		writable: !0,
+		enumerable: !0,
+		configurable: !0
+	});
+}
+function mergeDefs(...u) {
+	let z = {};
+	for (let B of u) {
+		let u = Object.getOwnPropertyDescriptors(B);
+		Object.assign(z, u);
+	}
+	return Object.defineProperties({}, z);
+}
+function esc(u) {
+	return JSON.stringify(u);
+}
+function slugify(u) {
+	return u.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (...u) => {};
+function isObject(u) {
+	return typeof u == "object" && !!u && !Array.isArray(u);
+}
+const allowsEval = /* @__PURE__ */ cached(() => {
+	if (globalConfig.jitless || typeof navigator < "u" && navigator?.userAgent?.includes("Cloudflare")) return !1;
+	try {
+		return Function(""), !0;
+	} catch {
+		return !1;
+	}
+});
+function isPlainObject(u) {
+	if (isObject(u) === !1) return !1;
+	let z = u.constructor;
+	if (z === void 0 || typeof z != "function") return !0;
+	let B = z.prototype;
+	return !(isObject(B) === !1 || Object.prototype.hasOwnProperty.call(B, "isPrototypeOf") === !1);
+}
+function shallowClone(u) {
+	return isPlainObject(u) ? { ...u } : Array.isArray(u) ? [...u] : u instanceof Map ? new Map(u) : u instanceof Set ? new Set(u) : u;
+}
+const propertyKeyTypes = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"symbol"
+]);
+function escapeRegex(u) {
+	return u.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(u, z, B) {
+	let V = new u._zod.constr(z ?? u._zod.def);
+	return (!z || B?.parent) && (V._zod.parent = u), V;
+}
+function normalizeParams(u) {
+	let z = u;
+	if (!z) return {};
+	if (typeof z == "string") return { error: () => z };
+	if (z?.message !== void 0) {
+		if (z?.error !== void 0) throw Error("Cannot specify both `message` and `error` params");
+		z.error = z.message;
+	}
+	return delete z.message, typeof z.error == "string" ? {
+		...z,
+		error: () => z.error
+	} : z;
+}
+function optionalKeys(u) {
+	return Object.keys(u).filter((z) => u[z]._zod.optin === "optional" && u[z]._zod.optout === "optional");
+}
+-Number.MAX_VALUE, Number.MAX_VALUE;
+function pick(u, z) {
+	let B = u._zod.def, V = B.checks;
+	if (V && V.length > 0) throw Error(".pick() cannot be used on object schemas containing refinements");
+	return clone(u, mergeDefs(u._zod.def, {
+		get shape() {
+			let u = {};
+			for (let V in z) {
+				if (!(V in B.shape)) throw Error(`Unrecognized key: "${V}"`);
+				z[V] && (u[V] = B.shape[V]);
+			}
+			return assignProp(this, "shape", u), u;
+		},
+		checks: []
+	}));
+}
+function omit(u, z) {
+	let B = u._zod.def, V = B.checks;
+	if (V && V.length > 0) throw Error(".omit() cannot be used on object schemas containing refinements");
+	return clone(u, mergeDefs(u._zod.def, {
+		get shape() {
+			let V = { ...u._zod.def.shape };
+			for (let u in z) {
+				if (!(u in B.shape)) throw Error(`Unrecognized key: "${u}"`);
+				z[u] && delete V[u];
+			}
+			return assignProp(this, "shape", V), V;
+		},
+		checks: []
+	}));
+}
+function extend(u, z) {
+	if (!isPlainObject(z)) throw Error("Invalid input to extend: expected a plain object");
+	let B = u._zod.def.checks;
+	if (B && B.length > 0) {
+		let B = u._zod.def.shape;
+		for (let u in z) if (Object.getOwnPropertyDescriptor(B, u) !== void 0) throw Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+	}
+	return clone(u, mergeDefs(u._zod.def, { get shape() {
+		let B = {
+			...u._zod.def.shape,
+			...z
+		};
+		return assignProp(this, "shape", B), B;
+	} }));
+}
+function safeExtend(u, z) {
+	if (!isPlainObject(z)) throw Error("Invalid input to safeExtend: expected a plain object");
+	return clone(u, mergeDefs(u._zod.def, { get shape() {
+		let B = {
+			...u._zod.def.shape,
+			...z
+		};
+		return assignProp(this, "shape", B), B;
+	} }));
+}
+function merge(u, z) {
+	if (u._zod.def.checks?.length) throw Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
+	return clone(u, mergeDefs(u._zod.def, {
+		get shape() {
+			let B = {
+				...u._zod.def.shape,
+				...z._zod.def.shape
+			};
+			return assignProp(this, "shape", B), B;
+		},
+		get catchall() {
+			return z._zod.def.catchall;
+		},
+		checks: z._zod.def.checks ?? []
+	}));
+}
+function partial(u, z, B) {
+	let V = z._zod.def.checks;
+	if (V && V.length > 0) throw Error(".partial() cannot be used on object schemas containing refinements");
+	return clone(z, mergeDefs(z._zod.def, {
+		get shape() {
+			let V = z._zod.def.shape, H = { ...V };
+			if (B) for (let z in B) {
+				if (!(z in V)) throw Error(`Unrecognized key: "${z}"`);
+				B[z] && (H[z] = u ? new u({
+					type: "optional",
+					innerType: V[z]
+				}) : V[z]);
+			}
+			else for (let z in V) H[z] = u ? new u({
+				type: "optional",
+				innerType: V[z]
+			}) : V[z];
+			return assignProp(this, "shape", H), H;
+		},
+		checks: []
+	}));
+}
+function required(u, z, B) {
+	return clone(z, mergeDefs(z._zod.def, { get shape() {
+		let V = z._zod.def.shape, H = { ...V };
+		if (B) for (let z in B) {
+			if (!(z in H)) throw Error(`Unrecognized key: "${z}"`);
+			B[z] && (H[z] = new u({
+				type: "nonoptional",
+				innerType: V[z]
+			}));
+		}
+		else for (let z in V) H[z] = new u({
+			type: "nonoptional",
+			innerType: V[z]
+		});
+		return assignProp(this, "shape", H), H;
+	} }));
+}
+function aborted(u, z = 0) {
+	if (u.aborted === !0) return !0;
+	for (let B = z; B < u.issues.length; B++) if (u.issues[B]?.continue !== !0) return !0;
+	return !1;
+}
+function explicitlyAborted(u, z = 0) {
+	if (u.aborted === !0) return !0;
+	for (let B = z; B < u.issues.length; B++) if (u.issues[B]?.continue === !1) return !0;
+	return !1;
+}
+function prefixIssues(u, z) {
+	return z.map((z) => {
+		var B;
+		return (B = z).path ?? (B.path = []), z.path.unshift(u), z;
+	});
+}
+function unwrapMessage(u) {
+	return typeof u == "string" ? u : u?.message;
+}
+function finalizeIssue(u, z, B) {
+	let V = u.message ? u.message : unwrapMessage(u.inst?._zod.def?.error?.(u)) ?? unwrapMessage(z?.error?.(u)) ?? unwrapMessage(B.customError?.(u)) ?? unwrapMessage(B.localeError?.(u)) ?? "Invalid input", { inst: H, continue: U, input: W,...G } = u;
+	return G.path ??= [], G.message = V, z?.reportInput && (G.input = W), G;
+}
+function getLengthableOrigin(u) {
+	return Array.isArray(u) ? "array" : typeof u == "string" ? "string" : "unknown";
+}
+function issue(...u) {
+	let [z, B, V] = u;
+	return typeof z == "string" ? {
+		message: z,
+		code: "custom",
+		input: B,
+		inst: V
+	} : { ...z };
+}
+var initializer$1 = (u, z) => {
+	u.name = "$ZodError", Object.defineProperty(u, "_zod", {
+		value: u._zod,
+		enumerable: !1
+	}), Object.defineProperty(u, "issues", {
+		value: z,
+		enumerable: !1
+	}), u.message = JSON.stringify(z, jsonStringifyReplacer, 2), Object.defineProperty(u, "toString", {
+		value: () => u.message,
+		enumerable: !1
+	});
+};
+const $ZodError = $constructor("$ZodError", initializer$1), $ZodRealError = $constructor("$ZodError", initializer$1, { Parent: Error });
+function flattenError(u, z = (u) => u.message) {
+	let B = {}, V = [];
+	for (let H of u.issues) H.path.length > 0 ? (B[H.path[0]] = B[H.path[0]] || [], B[H.path[0]].push(z(H))) : V.push(z(H));
+	return {
+		formErrors: V,
+		fieldErrors: B
+	};
+}
+function formatError(u, z = (u) => u.message) {
+	let B = { _errors: [] }, V = (u, H = []) => {
+		for (let U of u.issues) if (U.code === "invalid_union" && U.errors.length) U.errors.map((u) => V({ issues: u }, [...H, ...U.path]));
+		else if (U.code === "invalid_key") V({ issues: U.issues }, [...H, ...U.path]);
+		else if (U.code === "invalid_element") V({ issues: U.issues }, [...H, ...U.path]);
+		else {
+			let u = [...H, ...U.path];
+			if (u.length === 0) B._errors.push(z(U));
+			else {
+				let V = B, H = 0;
+				for (; H < u.length;) {
+					let B = u[H];
+					H === u.length - 1 ? (V[B] = V[B] || { _errors: [] }, V[B]._errors.push(z(U))) : V[B] = V[B] || { _errors: [] }, V = V[B], H++;
+				}
+			}
+		}
+	};
+	return V(u), B;
+}
+const _parse = (u) => (z, B, V, H) => {
+	let U = V ? {
+		...V,
+		async: !1
+	} : { async: !1 }, W = z._zod.run({
+		value: B,
+		issues: []
+	}, U);
+	if (W instanceof Promise) throw new $ZodAsyncError();
+	if (W.issues.length) {
+		let z = new (H?.Err ?? u)(W.issues.map((u) => finalizeIssue(u, U, config())));
+		throw captureStackTrace(z, H?.callee), z;
+	}
+	return W.value;
+}, _parseAsync = (u) => async (z, B, V, H) => {
+	let U = V ? {
+		...V,
+		async: !0
+	} : { async: !0 }, W = z._zod.run({
+		value: B,
+		issues: []
+	}, U);
+	if (W instanceof Promise && (W = await W), W.issues.length) {
+		let z = new (H?.Err ?? u)(W.issues.map((u) => finalizeIssue(u, U, config())));
+		throw captureStackTrace(z, H?.callee), z;
+	}
+	return W.value;
+}, _safeParse = (u) => (z, B, V) => {
+	let H = V ? {
+		...V,
+		async: !1
+	} : { async: !1 }, U = z._zod.run({
+		value: B,
+		issues: []
+	}, H);
+	if (U instanceof Promise) throw new $ZodAsyncError();
+	return U.issues.length ? {
+		success: !1,
+		error: new (u ?? $ZodError)(U.issues.map((u) => finalizeIssue(u, H, config())))
+	} : {
+		success: !0,
+		data: U.value
+	};
+}, safeParse$1 = /* @__PURE__ */ _safeParse($ZodRealError), _safeParseAsync = (u) => async (z, B, V) => {
+	let H = V ? {
+		...V,
+		async: !0
+	} : { async: !0 }, U = z._zod.run({
+		value: B,
+		issues: []
+	}, H);
+	return U instanceof Promise && (U = await U), U.issues.length ? {
+		success: !1,
+		error: new u(U.issues.map((u) => finalizeIssue(u, H, config())))
+	} : {
+		success: !0,
+		data: U.value
+	};
+}, safeParseAsync$1 = /* @__PURE__ */ _safeParseAsync($ZodRealError), _encode = (u) => (z, B, V) => {
+	let H = V ? {
+		...V,
+		direction: "backward"
+	} : { direction: "backward" };
+	return _parse(u)(z, B, H);
+}, _decode = (u) => (z, B, V) => _parse(u)(z, B, V), _encodeAsync = (u) => async (z, B, V) => {
+	let H = V ? {
+		...V,
+		direction: "backward"
+	} : { direction: "backward" };
+	return _parseAsync(u)(z, B, H);
+}, _decodeAsync = (u) => async (z, B, V) => _parseAsync(u)(z, B, V), _safeEncode = (u) => (z, B, V) => {
+	let H = V ? {
+		...V,
+		direction: "backward"
+	} : { direction: "backward" };
+	return _safeParse(u)(z, B, H);
+}, _safeDecode = (u) => (z, B, V) => _safeParse(u)(z, B, V), _safeEncodeAsync = (u) => async (z, B, V) => {
+	let H = V ? {
+		...V,
+		direction: "backward"
+	} : { direction: "backward" };
+	return _safeParseAsync(u)(z, B, H);
+}, _safeDecodeAsync = (u) => async (z, B, V) => _safeParseAsync(u)(z, B, V), cuid = /^[cC][0-9a-z]{6,}$/, cuid2 = /^[0-9a-z]+$/, ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/, xid = /^[0-9a-vA-V]{20}$/, ksuid = /^[A-Za-z0-9]{27}$/, nanoid = /^[a-zA-Z0-9_-]{21}$/, duration$1 = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/, guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/, uuid = (u) => u ? /* @__PURE__ */ RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${u}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`) : /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/, email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+var _emoji$1 = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+function emoji() {
+	return new RegExp(_emoji$1, "u");
+}
+const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/, ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/, cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/, cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/, base64url = /^[A-Za-z0-9_-]*$/, httpProtocol = /^https?$/, e164 = /^\+[1-9]\d{6,14}$/;
+var dateSource = "(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))";
+const date$1 = /* @__PURE__ */ RegExp(`^${dateSource}$`);
+function timeSource(u) {
+	let z = "(?:[01]\\d|2[0-3]):[0-5]\\d";
+	return typeof u.precision == "number" ? u.precision === -1 ? `${z}` : u.precision === 0 ? `${z}:[0-5]\\d` : `${z}:[0-5]\\d\\.\\d{${u.precision}}` : `${z}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+}
+function time$1(u) {
+	return /* @__PURE__ */ RegExp(`^${timeSource(u)}$`);
+}
+function datetime$1(u) {
+	let z = timeSource({ precision: u.precision }), B = ["Z"];
+	u.local && B.push(""), u.offset && B.push("([+-](?:[01]\\d|2[0-3]):[0-5]\\d)");
+	let V = `${z}(?:${B.join("|")})`;
+	return /* @__PURE__ */ RegExp(`^${dateSource}T(?:${V})$`);
+}
+const string$1 = (u) => {
+	let z = u ? `[\\s\\S]{${u?.minimum ?? 0},${u?.maximum ?? ""}}` : "[\\s\\S]*";
+	return /* @__PURE__ */ RegExp(`^${z}$`);
+}, number = /^-?\d+(?:\.\d+)?$/, lowercase = /^[^A-Z]*$/, uppercase = /^[^a-z]*$/, $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (u, z) => {
+	var B;
+	u._zod ??= {}, u._zod.def = z, (B = u._zod).onattach ?? (B.onattach = []);
+}), $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (u, z) => {
+	var B;
+	$ZodCheck.init(u, z), (B = u._zod.def).when ?? (B.when = (u) => {
+		let z = u.value;
+		return !nullish(z) && z.length !== void 0;
+	}), u._zod.onattach.push((u) => {
+		let B = u._zod.bag.maximum ?? Infinity;
+		z.maximum < B && (u._zod.bag.maximum = z.maximum);
+	}), u._zod.check = (B) => {
+		let V = B.value;
+		if (V.length <= z.maximum) return;
+		let H = getLengthableOrigin(V);
+		B.issues.push({
+			origin: H,
+			code: "too_big",
+			maximum: z.maximum,
+			inclusive: !0,
+			input: V,
+			inst: u,
+			continue: !z.abort
+		});
+	};
+}), $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (u, z) => {
+	var B;
+	$ZodCheck.init(u, z), (B = u._zod.def).when ?? (B.when = (u) => {
+		let z = u.value;
+		return !nullish(z) && z.length !== void 0;
+	}), u._zod.onattach.push((u) => {
+		let B = u._zod.bag.minimum ?? -Infinity;
+		z.minimum > B && (u._zod.bag.minimum = z.minimum);
+	}), u._zod.check = (B) => {
+		let V = B.value;
+		if (V.length >= z.minimum) return;
+		let H = getLengthableOrigin(V);
+		B.issues.push({
+			origin: H,
+			code: "too_small",
+			minimum: z.minimum,
+			inclusive: !0,
+			input: V,
+			inst: u,
+			continue: !z.abort
+		});
+	};
+}), $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (u, z) => {
+	var B;
+	$ZodCheck.init(u, z), (B = u._zod.def).when ?? (B.when = (u) => {
+		let z = u.value;
+		return !nullish(z) && z.length !== void 0;
+	}), u._zod.onattach.push((u) => {
+		let B = u._zod.bag;
+		B.minimum = z.length, B.maximum = z.length, B.length = z.length;
+	}), u._zod.check = (B) => {
+		let V = B.value, H = V.length;
+		if (H === z.length) return;
+		let U = getLengthableOrigin(V), W = H > z.length;
+		B.issues.push({
+			origin: U,
+			...W ? {
+				code: "too_big",
+				maximum: z.length
+			} : {
+				code: "too_small",
+				minimum: z.length
+			},
+			inclusive: !0,
+			exact: !0,
+			input: B.value,
+			inst: u,
+			continue: !z.abort
+		});
+	};
+}), $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (u, z) => {
+	var B, V;
+	$ZodCheck.init(u, z), u._zod.onattach.push((u) => {
+		let B = u._zod.bag;
+		B.format = z.format, z.pattern && (B.patterns ??= /* @__PURE__ */ new Set(), B.patterns.add(z.pattern));
+	}), z.pattern ? (B = u._zod).check ?? (B.check = (B) => {
+		z.pattern.lastIndex = 0, !z.pattern.test(B.value) && B.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: z.format,
+			input: B.value,
+			...z.pattern ? { pattern: z.pattern.toString() } : {},
+			inst: u,
+			continue: !z.abort
+		});
+	}) : (V = u._zod).check ?? (V.check = () => {});
+}), $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (u, z) => {
+	$ZodCheckStringFormat.init(u, z), u._zod.check = (B) => {
+		z.pattern.lastIndex = 0, !z.pattern.test(B.value) && B.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "regex",
+			input: B.value,
+			pattern: z.pattern.toString(),
+			inst: u,
+			continue: !z.abort
+		});
+	};
+}), $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (u, z) => {
+	z.pattern ??= lowercase, $ZodCheckStringFormat.init(u, z);
+}), $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (u, z) => {
+	z.pattern ??= uppercase, $ZodCheckStringFormat.init(u, z);
+}), $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (u, z) => {
+	$ZodCheck.init(u, z);
+	let B = escapeRegex(z.includes), V = new RegExp(typeof z.position == "number" ? `^.{${z.position}}${B}` : B);
+	z.pattern = V, u._zod.onattach.push((u) => {
+		let z = u._zod.bag;
+		z.patterns ??= /* @__PURE__ */ new Set(), z.patterns.add(V);
+	}), u._zod.check = (B) => {
+		B.value.includes(z.includes, z.position) || B.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "includes",
+			includes: z.includes,
+			input: B.value,
+			inst: u,
+			continue: !z.abort
+		});
+	};
+}), $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (u, z) => {
+	$ZodCheck.init(u, z);
+	let B = /* @__PURE__ */ RegExp(`^${escapeRegex(z.prefix)}.*`);
+	z.pattern ??= B, u._zod.onattach.push((u) => {
+		let z = u._zod.bag;
+		z.patterns ??= /* @__PURE__ */ new Set(), z.patterns.add(B);
+	}), u._zod.check = (B) => {
+		B.value.startsWith(z.prefix) || B.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "starts_with",
+			prefix: z.prefix,
+			input: B.value,
+			inst: u,
+			continue: !z.abort
+		});
+	};
+}), $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (u, z) => {
+	$ZodCheck.init(u, z);
+	let B = /* @__PURE__ */ RegExp(`.*${escapeRegex(z.suffix)}$`);
+	z.pattern ??= B, u._zod.onattach.push((u) => {
+		let z = u._zod.bag;
+		z.patterns ??= /* @__PURE__ */ new Set(), z.patterns.add(B);
+	}), u._zod.check = (B) => {
+		B.value.endsWith(z.suffix) || B.issues.push({
+			origin: "string",
+			code: "invalid_format",
+			format: "ends_with",
+			suffix: z.suffix,
+			input: B.value,
+			inst: u,
+			continue: !z.abort
+		});
+	};
+}), $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (u, z) => {
+	$ZodCheck.init(u, z), u._zod.check = (u) => {
+		u.value = z.tx(u.value);
+	};
+});
+var Doc = class {
+	constructor(u = []) {
+		this.content = [], this.indent = 0, this && (this.args = u);
+	}
+	indented(u) {
+		this.indent += 1, u(this), --this.indent;
+	}
+	write(u) {
+		if (typeof u == "function") {
+			u(this, { execution: "sync" }), u(this, { execution: "async" });
+			return;
+		}
+		let z = u.split("\n").filter((u) => u), B = Math.min(...z.map((u) => u.length - u.trimStart().length)), V = z.map((u) => u.slice(B)).map((u) => " ".repeat(this.indent * 2) + u);
+		for (let u of V) this.content.push(u);
+	}
+	compile() {
+		let u = Function, z = this?.args, B = [...(this?.content ?? [""]).map((u) => `  ${u}`)];
+		return new u(...z, B.join("\n"));
+	}
+};
+const version = {
+	major: 4,
+	minor: 4,
+	patch: 3
+}, $ZodType = /* @__PURE__ */ $constructor("$ZodType", (u, z) => {
+	var B;
+	u ??= {}, u._zod.def = z, u._zod.bag = u._zod.bag || {}, u._zod.version = version;
+	let V = [...u._zod.def.checks ?? []];
+	u._zod.traits.has("$ZodCheck") && V.unshift(u);
+	for (let z of V) for (let B of z._zod.onattach) B(u);
+	if (V.length === 0) (B = u._zod).deferred ?? (B.deferred = []), u._zod.deferred?.push(() => {
+		u._zod.run = u._zod.parse;
+	});
+	else {
+		let z = (u, z, B) => {
+			let V = aborted(u), H;
+			for (let U of z) {
+				if (U._zod.def.when) {
+					if (explicitlyAborted(u) || !U._zod.def.when(u)) continue;
+				} else if (V) continue;
+				let z = u.issues.length, W = U._zod.check(u);
+				if (W instanceof Promise && B?.async === !1) throw new $ZodAsyncError();
+				if (H || W instanceof Promise) H = (H ?? Promise.resolve()).then(async () => {
+					await W, u.issues.length !== z && (V ||= aborted(u, z));
+				});
+				else {
+					if (u.issues.length === z) continue;
+					V ||= aborted(u, z);
+				}
+			}
+			return H ? H.then(() => u) : u;
+		}, B = (B, H, U) => {
+			if (aborted(B)) return B.aborted = !0, B;
+			let W = z(H, V, U);
+			if (W instanceof Promise) {
+				if (U.async === !1) throw new $ZodAsyncError();
+				return W.then((z) => u._zod.parse(z, U));
+			}
+			return u._zod.parse(W, U);
+		};
+		u._zod.run = (H, U) => {
+			if (U.skipChecks) return u._zod.parse(H, U);
+			if (U.direction === "backward") {
+				let z = u._zod.parse({
+					value: H.value,
+					issues: []
+				}, {
+					...U,
+					skipChecks: !0
+				});
+				return z instanceof Promise ? z.then((u) => B(u, H, U)) : B(z, H, U);
+			}
+			let W = u._zod.parse(H, U);
+			if (W instanceof Promise) {
+				if (U.async === !1) throw new $ZodAsyncError();
+				return W.then((u) => z(u, V, U));
+			}
+			return z(W, V, U);
+		};
+	}
+	defineLazy(u, "~standard", () => ({
+		validate: (z) => {
+			try {
+				let B = safeParse$1(u, z);
+				return B.success ? { value: B.data } : { issues: B.error?.issues };
+			} catch {
+				return safeParseAsync$1(u, z).then((u) => u.success ? { value: u.data } : { issues: u.error?.issues });
+			}
+		},
+		vendor: "zod",
+		version: 1
+	}));
+}), $ZodString = /* @__PURE__ */ $constructor("$ZodString", (u, z) => {
+	$ZodType.init(u, z), u._zod.pattern = [...u?._zod.bag?.patterns ?? []].pop() ?? string$1(u._zod.bag), u._zod.parse = (B, V) => {
+		if (z.coerce) try {
+			B.value = String(B.value);
+		} catch {}
+		return typeof B.value == "string" || B.issues.push({
+			expected: "string",
+			code: "invalid_type",
+			input: B.value,
+			inst: u
+		}), B;
+	};
+}), $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (u, z) => {
+	$ZodCheckStringFormat.init(u, z), $ZodString.init(u, z);
+}), $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (u, z) => {
+	z.pattern ??= guid, $ZodStringFormat.init(u, z);
+}), $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (u, z) => {
+	if (z.version) {
+		let u = {
+			v1: 1,
+			v2: 2,
+			v3: 3,
+			v4: 4,
+			v5: 5,
+			v6: 6,
+			v7: 7,
+			v8: 8
+		}[z.version];
+		if (u === void 0) throw Error(`Invalid UUID version: "${z.version}"`);
+		z.pattern ??= uuid(u);
+	} else z.pattern ??= uuid();
+	$ZodStringFormat.init(u, z);
+}), $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (u, z) => {
+	z.pattern ??= email, $ZodStringFormat.init(u, z);
+}), $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (u, z) => {
+	$ZodStringFormat.init(u, z), u._zod.check = (B) => {
+		try {
+			let V = B.value.trim();
+			if (!z.normalize && z.protocol?.source === httpProtocol.source && !/^https?:\/\//i.test(V)) {
+				B.issues.push({
+					code: "invalid_format",
+					format: "url",
+					note: "Invalid URL format",
+					input: B.value,
+					inst: u,
+					continue: !z.abort
+				});
+				return;
+			}
+			let H = new URL(V);
+			z.hostname && (z.hostname.lastIndex = 0, z.hostname.test(H.hostname) || B.issues.push({
+				code: "invalid_format",
+				format: "url",
+				note: "Invalid hostname",
+				pattern: z.hostname.source,
+				input: B.value,
+				inst: u,
+				continue: !z.abort
+			})), z.protocol && (z.protocol.lastIndex = 0, z.protocol.test(H.protocol.endsWith(":") ? H.protocol.slice(0, -1) : H.protocol) || B.issues.push({
+				code: "invalid_format",
+				format: "url",
+				note: "Invalid protocol",
+				pattern: z.protocol.source,
+				input: B.value,
+				inst: u,
+				continue: !z.abort
+			})), z.normalize ? B.value = H.href : B.value = V;
+			return;
+		} catch {
+			B.issues.push({
+				code: "invalid_format",
+				format: "url",
+				input: B.value,
+				inst: u,
+				continue: !z.abort
+			});
+		}
+	};
+}), $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (u, z) => {
+	z.pattern ??= emoji(), $ZodStringFormat.init(u, z);
+}), $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (u, z) => {
+	z.pattern ??= nanoid, $ZodStringFormat.init(u, z);
+}), $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (u, z) => {
+	z.pattern ??= cuid, $ZodStringFormat.init(u, z);
+}), $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (u, z) => {
+	z.pattern ??= cuid2, $ZodStringFormat.init(u, z);
+}), $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (u, z) => {
+	z.pattern ??= ulid, $ZodStringFormat.init(u, z);
+}), $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (u, z) => {
+	z.pattern ??= xid, $ZodStringFormat.init(u, z);
+}), $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (u, z) => {
+	z.pattern ??= ksuid, $ZodStringFormat.init(u, z);
+}), $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (u, z) => {
+	z.pattern ??= datetime$1(z), $ZodStringFormat.init(u, z);
+}), $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (u, z) => {
+	z.pattern ??= date$1, $ZodStringFormat.init(u, z);
+}), $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (u, z) => {
+	z.pattern ??= time$1(z), $ZodStringFormat.init(u, z);
+}), $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (u, z) => {
+	z.pattern ??= duration$1, $ZodStringFormat.init(u, z);
+}), $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (u, z) => {
+	z.pattern ??= ipv4, $ZodStringFormat.init(u, z), u._zod.bag.format = "ipv4";
+}), $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (u, z) => {
+	z.pattern ??= ipv6, $ZodStringFormat.init(u, z), u._zod.bag.format = "ipv6", u._zod.check = (B) => {
+		try {
+			new URL(`http://[${B.value}]`);
+		} catch {
+			B.issues.push({
+				code: "invalid_format",
+				format: "ipv6",
+				input: B.value,
+				inst: u,
+				continue: !z.abort
+			});
+		}
+	};
+}), $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (u, z) => {
+	z.pattern ??= cidrv4, $ZodStringFormat.init(u, z);
+}), $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (u, z) => {
+	z.pattern ??= cidrv6, $ZodStringFormat.init(u, z), u._zod.check = (B) => {
+		let V = B.value.split("/");
+		try {
+			if (V.length !== 2) throw Error();
+			let [u, z] = V;
+			if (!z) throw Error();
+			let B = Number(z);
+			if (`${B}` !== z || B < 0 || B > 128) throw Error();
+			new URL(`http://[${u}]`);
+		} catch {
+			B.issues.push({
+				code: "invalid_format",
+				format: "cidrv6",
+				input: B.value,
+				inst: u,
+				continue: !z.abort
+			});
+		}
+	};
+});
+function isValidBase64(u) {
+	if (u === "") return !0;
+	if (/\s/.test(u) || u.length % 4 != 0) return !1;
+	try {
+		return atob(u), !0;
+	} catch {
+		return !1;
+	}
+}
+const $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (u, z) => {
+	z.pattern ??= base64, $ZodStringFormat.init(u, z), u._zod.bag.contentEncoding = "base64", u._zod.check = (B) => {
+		isValidBase64(B.value) || B.issues.push({
+			code: "invalid_format",
+			format: "base64",
+			input: B.value,
+			inst: u,
+			continue: !z.abort
+		});
+	};
+});
+function isValidBase64URL(u) {
+	if (!base64url.test(u)) return !1;
+	let z = u.replace(/[-_]/g, (u) => u === "-" ? "+" : "/");
+	return isValidBase64(z.padEnd(Math.ceil(z.length / 4) * 4, "="));
+}
+const $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (u, z) => {
+	z.pattern ??= base64url, $ZodStringFormat.init(u, z), u._zod.bag.contentEncoding = "base64url", u._zod.check = (B) => {
+		isValidBase64URL(B.value) || B.issues.push({
+			code: "invalid_format",
+			format: "base64url",
+			input: B.value,
+			inst: u,
+			continue: !z.abort
+		});
+	};
+}), $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (u, z) => {
+	z.pattern ??= e164, $ZodStringFormat.init(u, z);
+});
+function isValidJWT(u, z = null) {
+	try {
+		let B = u.split(".");
+		if (B.length !== 3) return !1;
+		let [V] = B;
+		if (!V) return !1;
+		let H = JSON.parse(atob(V));
+		return !("typ" in H && H?.typ !== "JWT" || !H.alg || z && (!("alg" in H) || H.alg !== z));
+	} catch {
+		return !1;
+	}
+}
+const $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (u, z) => {
+	$ZodStringFormat.init(u, z), u._zod.check = (B) => {
+		isValidJWT(B.value, z.alg) || B.issues.push({
+			code: "invalid_format",
+			format: "jwt",
+			input: B.value,
+			inst: u,
+			continue: !z.abort
+		});
+	};
+}), $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (u, z) => {
+	$ZodType.init(u, z), u._zod.parse = (u) => u;
+}), $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (u, z) => {
+	$ZodType.init(u, z), u._zod.parse = (z, B) => (z.issues.push({
+		expected: "never",
+		code: "invalid_type",
+		input: z.value,
+		inst: u
+	}), z);
+});
+function handleArrayResult(u, z, B) {
+	u.issues.length && z.issues.push(...prefixIssues(B, u.issues)), z.value[B] = u.value;
+}
+const $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (u, z) => {
+	$ZodType.init(u, z), u._zod.parse = (B, V) => {
+		let H = B.value;
+		if (!Array.isArray(H)) return B.issues.push({
+			expected: "array",
+			code: "invalid_type",
+			input: H,
+			inst: u
+		}), B;
+		B.value = Array(H.length);
+		let U = [];
+		for (let u = 0; u < H.length; u++) {
+			let W = H[u], G = z.element._zod.run({
+				value: W,
+				issues: []
+			}, V);
+			G instanceof Promise ? U.push(G.then((z) => handleArrayResult(z, B, u))) : handleArrayResult(G, B, u);
+		}
+		return U.length ? Promise.all(U).then(() => B) : B;
+	};
+});
+function handlePropertyResult(u, z, B, V, H, U) {
+	let W = B in V;
+	if (u.issues.length) {
+		if (H && U && !W) return;
+		z.issues.push(...prefixIssues(B, u.issues));
+	}
+	if (!W && !H) {
+		u.issues.length || z.issues.push({
+			code: "invalid_type",
+			expected: "nonoptional",
+			input: void 0,
+			path: [B]
+		});
+		return;
+	}
+	u.value === void 0 ? W && (z.value[B] = void 0) : z.value[B] = u.value;
+}
+function normalizeDef(u) {
+	let z = Object.keys(u.shape);
+	for (let B of z) if (!u.shape?.[B]?._zod?.traits?.has("$ZodType")) throw Error(`Invalid element at key "${B}": expected a Zod schema`);
+	let B = optionalKeys(u.shape);
+	return {
+		...u,
+		keys: z,
+		keySet: new Set(z),
+		numKeys: z.length,
+		optionalKeys: new Set(B)
+	};
+}
+function handleCatchall(u, z, B, V, H, U) {
+	let W = [], G = H.keySet, K = H.catchall._zod, q = K.def.type, J = K.optin === "optional", Y = K.optout === "optional";
+	for (let H in z) {
+		if (H === "__proto__" || G.has(H)) continue;
+		if (q === "never") {
+			W.push(H);
+			continue;
+		}
+		let U = K.run({
+			value: z[H],
+			issues: []
+		}, V);
+		U instanceof Promise ? u.push(U.then((u) => handlePropertyResult(u, B, H, z, J, Y))) : handlePropertyResult(U, B, H, z, J, Y);
+	}
+	return W.length && B.issues.push({
+		code: "unrecognized_keys",
+		keys: W,
+		input: z,
+		inst: U
+	}), u.length ? Promise.all(u).then(() => B) : B;
+}
+const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (u, z) => {
+	if ($ZodType.init(u, z), !Object.getOwnPropertyDescriptor(z, "shape")?.get) {
+		let u = z.shape;
+		Object.defineProperty(z, "shape", { get: () => {
+			let B = { ...u };
+			return Object.defineProperty(z, "shape", { value: B }), B;
+		} });
+	}
+	let B = cached(() => normalizeDef(z));
+	defineLazy(u._zod, "propValues", () => {
+		let u = z.shape, B = {};
+		for (let z in u) {
+			let V = u[z]._zod;
+			if (V.values) {
+				B[z] ?? (B[z] = /* @__PURE__ */ new Set());
+				for (let u of V.values) B[z].add(u);
+			}
+		}
+		return B;
+	});
+	let V = isObject, H = z.catchall, U;
+	u._zod.parse = (z, W) => {
+		U ??= B.value;
+		let G = z.value;
+		if (!V(G)) return z.issues.push({
+			expected: "object",
+			code: "invalid_type",
+			input: G,
+			inst: u
+		}), z;
+		z.value = {};
+		let K = [], q = U.shape;
+		for (let u of U.keys) {
+			let B = q[u], V = B._zod.optin === "optional", H = B._zod.optout === "optional", U = B._zod.run({
+				value: G[u],
+				issues: []
+			}, W);
+			U instanceof Promise ? K.push(U.then((B) => handlePropertyResult(B, z, u, G, V, H))) : handlePropertyResult(U, z, u, G, V, H);
+		}
+		return H ? handleCatchall(K, G, z, W, B.value, u) : K.length ? Promise.all(K).then(() => z) : z;
+	};
+}), $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (u, z) => {
+	$ZodObject.init(u, z);
+	let B = u._zod.parse, V = cached(() => normalizeDef(z)), H = (u) => {
+		let z = new Doc([
+			"shape",
+			"payload",
+			"ctx"
+		]), B = V.value, H = (u) => {
+			let z = esc(u);
+			return `shape[${z}]._zod.run({ value: input[${z}], issues: [] }, ctx)`;
+		};
+		z.write("const input = payload.value;");
+		let U = Object.create(null), W = 0;
+		for (let u of B.keys) U[u] = `key_${W++}`;
+		z.write("const newResult = {};");
+		for (let V of B.keys) {
+			let B = U[V], W = esc(V), G = u[V], K = G?._zod?.optin === "optional", q = G?._zod?.optout === "optional";
+			z.write(`const ${B} = ${H(V)};`), K && q ? z.write(`
+        if (${B}.issues.length) {
+          if (${W} in input) {
+            payload.issues = payload.issues.concat(${B}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${W}, ...iss.path] : [${W}]
+            })));
+          }
+        }
+        
+        if (${B}.value === undefined) {
+          if (${W} in input) {
+            newResult[${W}] = undefined;
+          }
+        } else {
+          newResult[${W}] = ${B}.value;
+        }
+        
+      `) : K ? z.write(`
+        if (${B}.issues.length) {
+          payload.issues = payload.issues.concat(${B}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${W}, ...iss.path] : [${W}]
+          })));
+        }
+        
+        if (${B}.value === undefined) {
+          if (${W} in input) {
+            newResult[${W}] = undefined;
+          }
+        } else {
+          newResult[${W}] = ${B}.value;
+        }
+        
+      `) : z.write(`
+        const ${B}_present = ${W} in input;
+        if (${B}.issues.length) {
+          payload.issues = payload.issues.concat(${B}.issues.map(iss => ({
+            ...iss,
+            path: iss.path ? [${W}, ...iss.path] : [${W}]
+          })));
+        }
+        if (!${B}_present && !${B}.issues.length) {
+          payload.issues.push({
+            code: "invalid_type",
+            expected: "nonoptional",
+            input: undefined,
+            path: [${W}]
+          });
+        }
+
+        if (${B}_present) {
+          if (${B}.value === undefined) {
+            newResult[${W}] = undefined;
+          } else {
+            newResult[${W}] = ${B}.value;
+          }
+        }
+
+      `);
+		}
+		z.write("payload.value = newResult;"), z.write("return payload;");
+		let G = z.compile();
+		return (z, B) => G(u, z, B);
+	}, U, W = isObject, G = !globalConfig.jitless, K = G && allowsEval.value, q = z.catchall, J;
+	u._zod.parse = (Y, X) => {
+		J ??= V.value;
+		let Z = Y.value;
+		return W(Z) ? G && K && X?.async === !1 && X.jitless !== !0 ? (U ||= H(z.shape), Y = U(Y, X), q ? handleCatchall([], Z, Y, X, J, u) : Y) : B(Y, X) : (Y.issues.push({
+			expected: "object",
+			code: "invalid_type",
+			input: Z,
+			inst: u
+		}), Y);
+	};
+});
+function handleUnionResults(u, z, B, V) {
+	for (let B of u) if (B.issues.length === 0) return z.value = B.value, z;
+	let H = u.filter((u) => !aborted(u));
+	return H.length === 1 ? (z.value = H[0].value, H[0]) : (z.issues.push({
+		code: "invalid_union",
+		input: z.value,
+		inst: B,
+		errors: u.map((u) => u.issues.map((u) => finalizeIssue(u, V, config())))
+	}), z);
+}
+const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (u, z) => {
+	$ZodType.init(u, z), defineLazy(u._zod, "optin", () => z.options.some((u) => u._zod.optin === "optional") ? "optional" : void 0), defineLazy(u._zod, "optout", () => z.options.some((u) => u._zod.optout === "optional") ? "optional" : void 0), defineLazy(u._zod, "values", () => {
+		if (z.options.every((u) => u._zod.values)) return new Set(z.options.flatMap((u) => Array.from(u._zod.values)));
+	}), defineLazy(u._zod, "pattern", () => {
+		if (z.options.every((u) => u._zod.pattern)) {
+			let u = z.options.map((u) => u._zod.pattern);
+			return /* @__PURE__ */ RegExp(`^(${u.map((u) => cleanRegex(u.source)).join("|")})$`);
+		}
+	});
+	let B = z.options.length === 1 ? z.options[0]._zod.run : null;
+	u._zod.parse = (V, H) => {
+		if (B) return B(V, H);
+		let U = !1, W = [];
+		for (let u of z.options) {
+			let z = u._zod.run({
+				value: V.value,
+				issues: []
+			}, H);
+			if (z instanceof Promise) W.push(z), U = !0;
+			else {
+				if (z.issues.length === 0) return z;
+				W.push(z);
+			}
+		}
+		return U ? Promise.all(W).then((z) => handleUnionResults(z, V, u, H)) : handleUnionResults(W, V, u, H);
+	};
+}), $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (u, z) => {
+	$ZodType.init(u, z), u._zod.parse = (u, B) => {
+		let V = u.value, H = z.left._zod.run({
+			value: V,
+			issues: []
+		}, B), U = z.right._zod.run({
+			value: V,
+			issues: []
+		}, B);
+		return H instanceof Promise || U instanceof Promise ? Promise.all([H, U]).then(([z, B]) => handleIntersectionResults(u, z, B)) : handleIntersectionResults(u, H, U);
+	};
+});
+function mergeValues(u, z) {
+	if (u === z || u instanceof Date && z instanceof Date && +u == +z) return {
+		valid: !0,
+		data: u
+	};
+	if (isPlainObject(u) && isPlainObject(z)) {
+		let B = Object.keys(z), V = Object.keys(u).filter((u) => B.indexOf(u) !== -1), H = {
+			...u,
+			...z
+		};
+		for (let B of V) {
+			let V = mergeValues(u[B], z[B]);
+			if (!V.valid) return {
+				valid: !1,
+				mergeErrorPath: [B, ...V.mergeErrorPath]
+			};
+			H[B] = V.data;
+		}
+		return {
+			valid: !0,
+			data: H
+		};
+	}
+	if (Array.isArray(u) && Array.isArray(z)) {
+		if (u.length !== z.length) return {
+			valid: !1,
+			mergeErrorPath: []
+		};
+		let B = [];
+		for (let V = 0; V < u.length; V++) {
+			let H = u[V], U = z[V], W = mergeValues(H, U);
+			if (!W.valid) return {
+				valid: !1,
+				mergeErrorPath: [V, ...W.mergeErrorPath]
+			};
+			B.push(W.data);
+		}
+		return {
+			valid: !0,
+			data: B
+		};
+	}
+	return {
+		valid: !1,
+		mergeErrorPath: []
+	};
+}
+function handleIntersectionResults(u, z, B) {
+	let V = /* @__PURE__ */ new Map(), H;
+	for (let B of z.issues) if (B.code === "unrecognized_keys") {
+		H ??= B;
+		for (let u of B.keys) V.has(u) || V.set(u, {}), V.get(u).l = !0;
+	} else u.issues.push(B);
+	for (let z of B.issues) if (z.code === "unrecognized_keys") for (let u of z.keys) V.has(u) || V.set(u, {}), V.get(u).r = !0;
+	else u.issues.push(z);
+	let U = [...V].filter(([, u]) => u.l && u.r).map(([u]) => u);
+	if (U.length && H && u.issues.push({
+		...H,
+		keys: U
+	}), aborted(u)) return u;
+	let W = mergeValues(z.value, B.value);
+	if (!W.valid) throw Error(`Unmergable intersection. Error path: ${JSON.stringify(W.mergeErrorPath)}`);
+	return u.value = W.data, u;
+}
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (u, z) => {
+	$ZodType.init(u, z), u._zod.parse = (B, V) => {
+		let H = B.value;
+		if (!isPlainObject(H)) return B.issues.push({
+			expected: "record",
+			code: "invalid_type",
+			input: H,
+			inst: u
+		}), B;
+		let U = [], W = z.keyType._zod.values;
+		if (W) {
+			B.value = {};
+			let G = /* @__PURE__ */ new Set();
+			for (let K of W) if (typeof K == "string" || typeof K == "number" || typeof K == "symbol") {
+				G.add(typeof K == "number" ? K.toString() : K);
+				let W = z.keyType._zod.run({
+					value: K,
+					issues: []
+				}, V);
+				if (W instanceof Promise) throw Error("Async schemas not supported in object keys currently");
+				if (W.issues.length) {
+					B.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: W.issues.map((u) => finalizeIssue(u, V, config())),
+						input: K,
+						path: [K],
+						inst: u
+					});
+					continue;
+				}
+				let q = W.value, J = z.valueType._zod.run({
+					value: H[K],
+					issues: []
+				}, V);
+				J instanceof Promise ? U.push(J.then((u) => {
+					u.issues.length && B.issues.push(...prefixIssues(K, u.issues)), B.value[q] = u.value;
+				})) : (J.issues.length && B.issues.push(...prefixIssues(K, J.issues)), B.value[q] = J.value);
+			}
+			let K;
+			for (let u in H) G.has(u) || (K ??= [], K.push(u));
+			K && K.length > 0 && B.issues.push({
+				code: "unrecognized_keys",
+				input: H,
+				inst: u,
+				keys: K
+			});
+		} else {
+			B.value = {};
+			for (let W of Reflect.ownKeys(H)) {
+				if (W === "__proto__" || !Object.prototype.propertyIsEnumerable.call(H, W)) continue;
+				let G = z.keyType._zod.run({
+					value: W,
+					issues: []
+				}, V);
+				if (G instanceof Promise) throw Error("Async schemas not supported in object keys currently");
+				if (typeof W == "string" && number.test(W) && G.issues.length) {
+					let u = z.keyType._zod.run({
+						value: Number(W),
+						issues: []
+					}, V);
+					if (u instanceof Promise) throw Error("Async schemas not supported in object keys currently");
+					u.issues.length === 0 && (G = u);
+				}
+				if (G.issues.length) {
+					z.mode === "loose" ? B.value[W] = H[W] : B.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: G.issues.map((u) => finalizeIssue(u, V, config())),
+						input: W,
+						path: [W],
+						inst: u
+					});
+					continue;
+				}
+				let K = z.valueType._zod.run({
+					value: H[W],
+					issues: []
+				}, V);
+				K instanceof Promise ? U.push(K.then((u) => {
+					u.issues.length && B.issues.push(...prefixIssues(W, u.issues)), B.value[G.value] = u.value;
+				})) : (K.issues.length && B.issues.push(...prefixIssues(W, K.issues)), B.value[G.value] = K.value);
+			}
+		}
+		return U.length ? Promise.all(U).then(() => B) : B;
+	};
+}), $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (u, z) => {
+	$ZodType.init(u, z);
+	let B = getEnumValues(z.entries), V = new Set(B);
+	u._zod.values = V, u._zod.pattern = /* @__PURE__ */ RegExp(`^(${B.filter((u) => propertyKeyTypes.has(typeof u)).map((u) => typeof u == "string" ? escapeRegex(u) : u.toString()).join("|")})$`), u._zod.parse = (z, H) => {
+		let U = z.value;
+		return V.has(U) || z.issues.push({
+			code: "invalid_value",
+			values: B,
+			input: U,
+			inst: u
+		}), z;
+	};
+}), $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (u, z) => {
+	$ZodType.init(u, z), u._zod.optin = "optional", u._zod.parse = (B, V) => {
+		if (V.direction === "backward") throw new $ZodEncodeError(u.constructor.name);
+		let H = z.transform(B.value, B);
+		if (V.async) return (H instanceof Promise ? H : Promise.resolve(H)).then((u) => (B.value = u, B.fallback = !0, B));
+		if (H instanceof Promise) throw new $ZodAsyncError();
+		return B.value = H, B.fallback = !0, B;
+	};
+});
+function handleOptionalResult(u, z) {
+	return z === void 0 && (u.issues.length || u.fallback) ? {
+		issues: [],
+		value: void 0
+	} : u;
+}
+const $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (u, z) => {
+	$ZodType.init(u, z), u._zod.optin = "optional", u._zod.optout = "optional", defineLazy(u._zod, "values", () => z.innerType._zod.values ? new Set([...z.innerType._zod.values, void 0]) : void 0), defineLazy(u._zod, "pattern", () => {
+		let u = z.innerType._zod.pattern;
+		return u ? /* @__PURE__ */ RegExp(`^(${cleanRegex(u.source)})?$`) : void 0;
+	}), u._zod.parse = (u, B) => {
+		if (z.innerType._zod.optin === "optional") {
+			let V = u.value, H = z.innerType._zod.run(u, B);
+			return H instanceof Promise ? H.then((u) => handleOptionalResult(u, V)) : handleOptionalResult(H, V);
+		}
+		return u.value === void 0 ? u : z.innerType._zod.run(u, B);
+	};
+}), $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (u, z) => {
+	$ZodOptional.init(u, z), defineLazy(u._zod, "values", () => z.innerType._zod.values), defineLazy(u._zod, "pattern", () => z.innerType._zod.pattern), u._zod.parse = (u, B) => z.innerType._zod.run(u, B);
+}), $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (u, z) => {
+	$ZodType.init(u, z), defineLazy(u._zod, "optin", () => z.innerType._zod.optin), defineLazy(u._zod, "optout", () => z.innerType._zod.optout), defineLazy(u._zod, "pattern", () => {
+		let u = z.innerType._zod.pattern;
+		return u ? /* @__PURE__ */ RegExp(`^(${cleanRegex(u.source)}|null)$`) : void 0;
+	}), defineLazy(u._zod, "values", () => z.innerType._zod.values ? new Set([...z.innerType._zod.values, null]) : void 0), u._zod.parse = (u, B) => u.value === null ? u : z.innerType._zod.run(u, B);
+}), $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (u, z) => {
+	$ZodType.init(u, z), u._zod.optin = "optional", defineLazy(u._zod, "values", () => z.innerType._zod.values), u._zod.parse = (u, B) => {
+		if (B.direction === "backward") return z.innerType._zod.run(u, B);
+		if (u.value === void 0) return u.value = z.defaultValue, u;
+		let V = z.innerType._zod.run(u, B);
+		return V instanceof Promise ? V.then((u) => handleDefaultResult(u, z)) : handleDefaultResult(V, z);
+	};
+});
+function handleDefaultResult(u, z) {
+	return u.value === void 0 && (u.value = z.defaultValue), u;
+}
+const $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (u, z) => {
+	$ZodType.init(u, z), u._zod.optin = "optional", defineLazy(u._zod, "values", () => z.innerType._zod.values), u._zod.parse = (u, B) => (B.direction === "backward" || u.value === void 0 && (u.value = z.defaultValue), z.innerType._zod.run(u, B));
+}), $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (u, z) => {
+	$ZodType.init(u, z), defineLazy(u._zod, "values", () => {
+		let u = z.innerType._zod.values;
+		return u ? new Set([...u].filter((u) => u !== void 0)) : void 0;
+	}), u._zod.parse = (B, V) => {
+		let H = z.innerType._zod.run(B, V);
+		return H instanceof Promise ? H.then((z) => handleNonOptionalResult(z, u)) : handleNonOptionalResult(H, u);
+	};
+});
+function handleNonOptionalResult(u, z) {
+	return !u.issues.length && u.value === void 0 && u.issues.push({
+		code: "invalid_type",
+		expected: "nonoptional",
+		input: u.value,
+		inst: z
+	}), u;
+}
+const $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (u, z) => {
+	$ZodType.init(u, z), u._zod.optin = "optional", defineLazy(u._zod, "optout", () => z.innerType._zod.optout), defineLazy(u._zod, "values", () => z.innerType._zod.values), u._zod.parse = (u, B) => {
+		if (B.direction === "backward") return z.innerType._zod.run(u, B);
+		let V = z.innerType._zod.run(u, B);
+		return V instanceof Promise ? V.then((V) => (u.value = V.value, V.issues.length && (u.value = z.catchValue({
+			...u,
+			error: { issues: V.issues.map((u) => finalizeIssue(u, B, config())) },
+			input: u.value
+		}), u.issues = [], u.fallback = !0), u)) : (u.value = V.value, V.issues.length && (u.value = z.catchValue({
+			...u,
+			error: { issues: V.issues.map((u) => finalizeIssue(u, B, config())) },
+			input: u.value
+		}), u.issues = [], u.fallback = !0), u);
+	};
+}), $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (u, z) => {
+	$ZodType.init(u, z), defineLazy(u._zod, "values", () => z.in._zod.values), defineLazy(u._zod, "optin", () => z.in._zod.optin), defineLazy(u._zod, "optout", () => z.out._zod.optout), defineLazy(u._zod, "propValues", () => z.in._zod.propValues), u._zod.parse = (u, B) => {
+		if (B.direction === "backward") {
+			let V = z.out._zod.run(u, B);
+			return V instanceof Promise ? V.then((u) => handlePipeResult(u, z.in, B)) : handlePipeResult(V, z.in, B);
+		}
+		let V = z.in._zod.run(u, B);
+		return V instanceof Promise ? V.then((u) => handlePipeResult(u, z.out, B)) : handlePipeResult(V, z.out, B);
+	};
+});
+function handlePipeResult(u, z, B) {
+	return u.issues.length ? (u.aborted = !0, u) : z._zod.run({
+		value: u.value,
+		issues: u.issues,
+		fallback: u.fallback
+	}, B);
+}
+const $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (u, z) => {
+	$ZodType.init(u, z), defineLazy(u._zod, "propValues", () => z.innerType._zod.propValues), defineLazy(u._zod, "values", () => z.innerType._zod.values), defineLazy(u._zod, "optin", () => z.innerType?._zod?.optin), defineLazy(u._zod, "optout", () => z.innerType?._zod?.optout), u._zod.parse = (u, B) => {
+		if (B.direction === "backward") return z.innerType._zod.run(u, B);
+		let V = z.innerType._zod.run(u, B);
+		return V instanceof Promise ? V.then(handleReadonlyResult) : handleReadonlyResult(V);
+	};
+});
+function handleReadonlyResult(u) {
+	return u.value = Object.freeze(u.value), u;
+}
+const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (u, z) => {
+	$ZodCheck.init(u, z), $ZodType.init(u, z), u._zod.parse = (u, z) => u, u._zod.check = (B) => {
+		let V = B.value, H = z.fn(V);
+		if (H instanceof Promise) return H.then((z) => handleRefineResult(z, B, V, u));
+		handleRefineResult(H, B, V, u);
+	};
+});
+function handleRefineResult(u, z, B, V) {
+	if (!u) {
+		let u = {
+			code: "custom",
+			input: B,
+			inst: V,
+			path: [...V._zod.def.path ?? []],
+			continue: !V._zod.def.abort
+		};
+		V._zod.def.params && (u.params = V._zod.def.params), z.issues.push(issue(u));
+	}
+}
+var _a, $ZodRegistry = class {
+	constructor() {
+		this._map = /* @__PURE__ */ new WeakMap(), this._idmap = /* @__PURE__ */ new Map();
+	}
+	add(u, ...z) {
+		let B = z[0];
+		return this._map.set(u, B), B && typeof B == "object" && "id" in B && this._idmap.set(B.id, u), this;
+	}
+	clear() {
+		return this._map = /* @__PURE__ */ new WeakMap(), this._idmap = /* @__PURE__ */ new Map(), this;
+	}
+	remove(u) {
+		let z = this._map.get(u);
+		return z && typeof z == "object" && "id" in z && this._idmap.delete(z.id), this._map.delete(u), this;
+	}
+	get(u) {
+		let z = u._zod.parent;
+		if (z) {
+			let B = { ...this.get(z) ?? {} };
+			delete B.id;
+			let V = {
+				...B,
+				...this._map.get(u)
+			};
+			return Object.keys(V).length ? V : void 0;
+		}
+		return this._map.get(u);
+	}
+	has(u) {
+		return this._map.has(u);
+	}
+};
+function registry() {
+	return new $ZodRegistry();
+}
+(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
+const globalRegistry = globalThis.__zod_globalRegistry;
+/* @__NO_SIDE_EFFECTS__ */
+function _string(u, z) {
+	return new u({
+		type: "string",
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _email(u, z) {
+	return new u({
+		type: "string",
+		format: "email",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _guid(u, z) {
+	return new u({
+		type: "string",
+		format: "guid",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuid(u, z) {
+	return new u({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv4(u, z) {
+	return new u({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: !1,
+		version: "v4",
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv6(u, z) {
+	return new u({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: !1,
+		version: "v6",
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uuidv7(u, z) {
+	return new u({
+		type: "string",
+		format: "uuid",
+		check: "string_format",
+		abort: !1,
+		version: "v7",
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _url(u, z) {
+	return new u({
+		type: "string",
+		format: "url",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _emoji(u, z) {
+	return new u({
+		type: "string",
+		format: "emoji",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _nanoid(u, z) {
+	return new u({
+		type: "string",
+		format: "nanoid",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cuid(u, z) {
+	return new u({
+		type: "string",
+		format: "cuid",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cuid2(u, z) {
+	return new u({
+		type: "string",
+		format: "cuid2",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ulid(u, z) {
+	return new u({
+		type: "string",
+		format: "ulid",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _xid(u, z) {
+	return new u({
+		type: "string",
+		format: "xid",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ksuid(u, z) {
+	return new u({
+		type: "string",
+		format: "ksuid",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ipv4(u, z) {
+	return new u({
+		type: "string",
+		format: "ipv4",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _ipv6(u, z) {
+	return new u({
+		type: "string",
+		format: "ipv6",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cidrv4(u, z) {
+	return new u({
+		type: "string",
+		format: "cidrv4",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _cidrv6(u, z) {
+	return new u({
+		type: "string",
+		format: "cidrv6",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _base64(u, z) {
+	return new u({
+		type: "string",
+		format: "base64",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _base64url(u, z) {
+	return new u({
+		type: "string",
+		format: "base64url",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _e164(u, z) {
+	return new u({
+		type: "string",
+		format: "e164",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _jwt(u, z) {
+	return new u({
+		type: "string",
+		format: "jwt",
+		check: "string_format",
+		abort: !1,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDateTime(u, z) {
+	return new u({
+		type: "string",
+		format: "datetime",
+		check: "string_format",
+		offset: !1,
+		local: !1,
+		precision: null,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDate(u, z) {
+	return new u({
+		type: "string",
+		format: "date",
+		check: "string_format",
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoTime(u, z) {
+	return new u({
+		type: "string",
+		format: "time",
+		check: "string_format",
+		precision: null,
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _isoDuration(u, z) {
+	return new u({
+		type: "string",
+		format: "duration",
+		check: "string_format",
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _unknown(u) {
+	return new u({ type: "unknown" });
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _never(u, z) {
+	return new u({
+		type: "never",
+		...normalizeParams(z)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _maxLength(u, z) {
+	return new $ZodCheckMaxLength({
+		check: "max_length",
+		...normalizeParams(z),
+		maximum: u
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _minLength(u, z) {
+	return new $ZodCheckMinLength({
+		check: "min_length",
+		...normalizeParams(z),
+		minimum: u
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _length(u, z) {
+	return new $ZodCheckLengthEquals({
+		check: "length_equals",
+		...normalizeParams(z),
+		length: u
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _regex(u, z) {
+	return new $ZodCheckRegex({
+		check: "string_format",
+		format: "regex",
+		...normalizeParams(z),
+		pattern: u
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _lowercase(u) {
+	return new $ZodCheckLowerCase({
+		check: "string_format",
+		format: "lowercase",
+		...normalizeParams(u)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _uppercase(u) {
+	return new $ZodCheckUpperCase({
+		check: "string_format",
+		format: "uppercase",
+		...normalizeParams(u)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _includes(u, z) {
+	return new $ZodCheckIncludes({
+		check: "string_format",
+		format: "includes",
+		...normalizeParams(z),
+		includes: u
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _startsWith(u, z) {
+	return new $ZodCheckStartsWith({
+		check: "string_format",
+		format: "starts_with",
+		...normalizeParams(z),
+		prefix: u
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _endsWith(u, z) {
+	return new $ZodCheckEndsWith({
+		check: "string_format",
+		format: "ends_with",
+		...normalizeParams(z),
+		suffix: u
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _overwrite(u) {
+	return new $ZodCheckOverwrite({
+		check: "overwrite",
+		tx: u
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _normalize(u) {
+	return /* @__PURE__ */ _overwrite((z) => z.normalize(u));
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _trim() {
+	return /* @__PURE__ */ _overwrite((u) => u.trim());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _toLowerCase() {
+	return /* @__PURE__ */ _overwrite((u) => u.toLowerCase());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _toUpperCase() {
+	return /* @__PURE__ */ _overwrite((u) => u.toUpperCase());
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _slugify() {
+	return /* @__PURE__ */ _overwrite((u) => slugify(u));
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _array(u, z, B) {
+	return new u({
+		type: "array",
+		element: z,
+		...normalizeParams(B)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _refine(u, z, B) {
+	return new u({
+		type: "custom",
+		check: "custom",
+		fn: z,
+		...normalizeParams(B)
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _superRefine(u, z) {
+	let B = /* @__PURE__ */ _check((z) => (z.addIssue = (u) => {
+		if (typeof u == "string") z.issues.push(issue(u, z.value, B._zod.def));
+		else {
+			let V = u;
+			V.fatal && (V.continue = !1), V.code ??= "custom", V.input ??= z.value, V.inst ??= B, V.continue ??= !B._zod.def.abort, z.issues.push(issue(V));
+		}
+	}, u(z.value, z)), z);
+	return B;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function _check(u, z) {
+	let B = new $ZodCheck({
+		check: "custom",
+		...normalizeParams(z)
+	});
+	return B._zod.check = u, B;
+}
+function initializeContext(u) {
+	let z = u?.target ?? "draft-2020-12";
+	return z === "draft-4" && (z = "draft-04"), z === "draft-7" && (z = "draft-07"), {
+		processors: u.processors ?? {},
+		metadataRegistry: u?.metadata ?? globalRegistry,
+		target: z,
+		unrepresentable: u?.unrepresentable ?? "throw",
+		override: u?.override ?? (() => {}),
+		io: u?.io ?? "output",
+		counter: 0,
+		seen: /* @__PURE__ */ new Map(),
+		cycles: u?.cycles ?? "ref",
+		reused: u?.reused ?? "inline",
+		external: u?.external ?? void 0
+	};
+}
+function process$1(u, z, B = {
+	path: [],
+	schemaPath: []
+}) {
+	var V;
+	let H = u._zod.def, U = z.seen.get(u);
+	if (U) return U.count++, B.schemaPath.includes(u) && (U.cycle = B.path), U.schema;
+	let W = {
+		schema: {},
+		count: 1,
+		cycle: void 0,
+		path: B.path
+	};
+	z.seen.set(u, W);
+	let G = u._zod.toJSONSchema?.();
+	if (G) W.schema = G;
+	else {
+		let V = {
+			...B,
+			schemaPath: [...B.schemaPath, u],
+			path: B.path
+		};
+		if (u._zod.processJSONSchema) u._zod.processJSONSchema(z, W.schema, V);
+		else {
+			let B = W.schema, U = z.processors[H.type];
+			if (!U) throw Error(`[toJSONSchema]: Non-representable type encountered: ${H.type}`);
+			U(u, z, B, V);
+		}
+		let U = u._zod.parent;
+		U && (W.ref ||= U, process$1(U, z, V), z.seen.get(U).isParent = !0);
+	}
+	let K = z.metadataRegistry.get(u);
+	return K && Object.assign(W.schema, K), z.io === "input" && isTransforming(u) && (delete W.schema.examples, delete W.schema.default), z.io === "input" && "_prefault" in W.schema && ((V = W.schema).default ?? (V.default = W.schema._prefault)), delete W.schema._prefault, z.seen.get(u).schema;
+}
+function extractDefs(u, z) {
+	let B = u.seen.get(z);
+	if (!B) throw Error("Unprocessed schema. This is a bug in Zod.");
+	let V = /* @__PURE__ */ new Map();
+	for (let z of u.seen.entries()) {
+		let B = u.metadataRegistry.get(z[0])?.id;
+		if (B) {
+			let u = V.get(B);
+			if (u && u !== z[0]) throw Error(`Duplicate schema id "${B}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+			V.set(B, z[0]);
+		}
+	}
+	let H = (z) => {
+		let V = u.target === "draft-2020-12" ? "$defs" : "definitions";
+		if (u.external) {
+			let B = u.external.registry.get(z[0])?.id, H = u.external.uri ?? ((u) => u);
+			if (B) return { ref: H(B) };
+			let U = z[1].defId ?? z[1].schema.id ?? `schema${u.counter++}`;
+			return z[1].defId = U, {
+				defId: U,
+				ref: `${H("__shared")}#/${V}/${U}`
+			};
+		}
+		if (z[1] === B) return { ref: "#" };
+		let H = `#/${V}/`, U = z[1].schema.id ?? `__schema${u.counter++}`;
+		return {
+			defId: U,
+			ref: H + U
+		};
+	}, U = (u) => {
+		if (u[1].schema.$ref) return;
+		let z = u[1], { ref: B, defId: V } = H(u);
+		z.def = { ...z.schema }, V && (z.defId = V);
+		let U = z.schema;
+		for (let u in U) delete U[u];
+		U.$ref = B;
+	};
+	if (u.cycles === "throw") for (let z of u.seen.entries()) {
+		let u = z[1];
+		if (u.cycle) throw Error(`Cycle detected: #/${u.cycle?.join("/")}/<root>
+
+Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
+	}
+	for (let B of u.seen.entries()) {
+		let V = B[1];
+		if (z === B[0]) {
+			U(B);
+			continue;
+		}
+		if (u.external) {
+			let V = u.external.registry.get(B[0])?.id;
+			if (z !== B[0] && V) {
+				U(B);
+				continue;
+			}
+		}
+		if (u.metadataRegistry.get(B[0])?.id) {
+			U(B);
+			continue;
+		}
+		if (V.cycle) {
+			U(B);
+			continue;
+		}
+		if (V.count > 1 && u.reused === "ref") {
+			U(B);
+			continue;
+		}
+	}
+}
+function finalize(u, z) {
+	let B = u.seen.get(z);
+	if (!B) throw Error("Unprocessed schema. This is a bug in Zod.");
+	let V = (z) => {
+		let B = u.seen.get(z);
+		if (B.ref === null) return;
+		let H = B.def ?? B.schema, U = { ...H }, W = B.ref;
+		if (B.ref = null, W) {
+			V(W);
+			let B = u.seen.get(W), G = B.schema;
+			if (G.$ref && (u.target === "draft-07" || u.target === "draft-04" || u.target === "openapi-3.0") ? (H.allOf = H.allOf ?? [], H.allOf.push(G)) : Object.assign(H, G), Object.assign(H, U), z._zod.parent === W) for (let u in H) u === "$ref" || u === "allOf" || u in U || delete H[u];
+			if (G.$ref && B.def) for (let u in H) u === "$ref" || u === "allOf" || u in B.def && JSON.stringify(H[u]) === JSON.stringify(B.def[u]) && delete H[u];
+		}
+		let G = z._zod.parent;
+		if (G && G !== W) {
+			V(G);
+			let z = u.seen.get(G);
+			if (z?.schema.$ref && (H.$ref = z.schema.$ref, z.def)) for (let u in H) u === "$ref" || u === "allOf" || u in z.def && JSON.stringify(H[u]) === JSON.stringify(z.def[u]) && delete H[u];
+		}
+		u.override({
+			zodSchema: z,
+			jsonSchema: H,
+			path: B.path ?? []
+		});
+	};
+	for (let z of [...u.seen.entries()].reverse()) V(z[0]);
+	let H = {};
+	if (u.target === "draft-2020-12" ? H.$schema = "https://json-schema.org/draft/2020-12/schema" : u.target === "draft-07" ? H.$schema = "http://json-schema.org/draft-07/schema#" : u.target === "draft-04" ? H.$schema = "http://json-schema.org/draft-04/schema#" : u.target, u.external?.uri) {
+		let B = u.external.registry.get(z)?.id;
+		if (!B) throw Error("Schema is missing an `id` property");
+		H.$id = u.external.uri(B);
+	}
+	Object.assign(H, B.def ?? B.schema);
+	let U = u.metadataRegistry.get(z)?.id;
+	U !== void 0 && H.id === U && delete H.id;
+	let W = u.external?.defs ?? {};
+	for (let z of u.seen.entries()) {
+		let u = z[1];
+		u.def && u.defId && (u.def.id === u.defId && delete u.def.id, W[u.defId] = u.def);
+	}
+	u.external || Object.keys(W).length > 0 && (u.target === "draft-2020-12" ? H.$defs = W : H.definitions = W);
+	try {
+		let B = JSON.parse(JSON.stringify(H));
+		return Object.defineProperty(B, "~standard", {
+			value: {
+				...z["~standard"],
+				jsonSchema: {
+					input: createStandardJSONSchemaMethod(z, "input", u.processors),
+					output: createStandardJSONSchemaMethod(z, "output", u.processors)
+				}
+			},
+			enumerable: !1,
+			writable: !1
+		}), B;
+	} catch {
+		throw Error("Error converting schema to JSON.");
+	}
+}
+function isTransforming(u, z) {
+	let B = z ?? { seen: /* @__PURE__ */ new Set() };
+	if (B.seen.has(u)) return !1;
+	B.seen.add(u);
+	let V = u._zod.def;
+	if (V.type === "transform") return !0;
+	if (V.type === "array") return isTransforming(V.element, B);
+	if (V.type === "set") return isTransforming(V.valueType, B);
+	if (V.type === "lazy") return isTransforming(V.getter(), B);
+	if (V.type === "promise" || V.type === "optional" || V.type === "nonoptional" || V.type === "nullable" || V.type === "readonly" || V.type === "default" || V.type === "prefault") return isTransforming(V.innerType, B);
+	if (V.type === "intersection") return isTransforming(V.left, B) || isTransforming(V.right, B);
+	if (V.type === "record" || V.type === "map") return isTransforming(V.keyType, B) || isTransforming(V.valueType, B);
+	if (V.type === "pipe") return u._zod.traits.has("$ZodCodec") ? !0 : isTransforming(V.in, B) || isTransforming(V.out, B);
+	if (V.type === "object") {
+		for (let u in V.shape) if (isTransforming(V.shape[u], B)) return !0;
+		return !1;
+	}
+	if (V.type === "union") {
+		for (let u of V.options) if (isTransforming(u, B)) return !0;
+		return !1;
+	}
+	if (V.type === "tuple") {
+		for (let u of V.items) if (isTransforming(u, B)) return !0;
+		return !!(V.rest && isTransforming(V.rest, B));
+	}
+	return !1;
+}
+const createToJSONSchemaMethod = (u, z = {}) => (B) => {
+	let V = initializeContext({
+		...B,
+		processors: z
+	});
+	return process$1(u, V), extractDefs(V, u), finalize(V, u);
+}, createStandardJSONSchemaMethod = (u, z, B = {}) => (V) => {
+	let { libraryOptions: H, target: U } = V ?? {}, W = initializeContext({
+		...H ?? {},
+		target: U,
+		io: z,
+		processors: B
+	});
+	return process$1(u, W), extractDefs(W, u), finalize(W, u);
+};
+var formatMap = {
+	guid: "uuid",
+	url: "uri",
+	datetime: "date-time",
+	json_string: "json-string",
+	regex: ""
+};
+const stringProcessor = (u, z, B, V) => {
+	let H = B;
+	H.type = "string";
+	let { minimum: U, maximum: W, format: G, patterns: K, contentEncoding: q } = u._zod.bag;
+	if (typeof U == "number" && (H.minLength = U), typeof W == "number" && (H.maxLength = W), G && (H.format = formatMap[G] ?? G, H.format === "" && delete H.format, G === "time" && delete H.format), q && (H.contentEncoding = q), K && K.size > 0) {
+		let u = [...K];
+		u.length === 1 ? H.pattern = u[0].source : u.length > 1 && (H.allOf = [...u.map((u) => ({
+			...z.target === "draft-07" || z.target === "draft-04" || z.target === "openapi-3.0" ? { type: "string" } : {},
+			pattern: u.source
+		}))]);
+	}
+}, neverProcessor = (u, z, B, V) => {
+	B.not = {};
+}, enumProcessor = (u, z, B, V) => {
+	let H = u._zod.def, U = getEnumValues(H.entries);
+	U.every((u) => typeof u == "number") && (B.type = "number"), U.every((u) => typeof u == "string") && (B.type = "string"), B.enum = U;
+}, customProcessor = (u, z, B, V) => {
+	if (z.unrepresentable === "throw") throw Error("Custom types cannot be represented in JSON Schema");
+}, transformProcessor = (u, z, B, V) => {
+	if (z.unrepresentable === "throw") throw Error("Transforms cannot be represented in JSON Schema");
+}, arrayProcessor = (u, z, B, V) => {
+	let H = B, U = u._zod.def, { minimum: W, maximum: G } = u._zod.bag;
+	typeof W == "number" && (H.minItems = W), typeof G == "number" && (H.maxItems = G), H.type = "array", H.items = process$1(U.element, z, {
+		...V,
+		path: [...V.path, "items"]
+	});
+}, objectProcessor = (u, z, B, V) => {
+	let H = B, U = u._zod.def;
+	H.type = "object", H.properties = {};
+	let W = U.shape;
+	for (let u in W) H.properties[u] = process$1(W[u], z, {
+		...V,
+		path: [
+			...V.path,
+			"properties",
+			u
+		]
+	});
+	let G = new Set(Object.keys(W)), K = new Set([...G].filter((u) => {
+		let B = U.shape[u]._zod;
+		return z.io === "input" ? B.optin === void 0 : B.optout === void 0;
+	}));
+	K.size > 0 && (H.required = Array.from(K)), U.catchall?._zod.def.type === "never" ? H.additionalProperties = !1 : U.catchall ? U.catchall && (H.additionalProperties = process$1(U.catchall, z, {
+		...V,
+		path: [...V.path, "additionalProperties"]
+	})) : z.io === "output" && (H.additionalProperties = !1);
+}, unionProcessor = (u, z, B, V) => {
+	let H = u._zod.def, U = H.inclusive === !1, W = H.options.map((u, B) => process$1(u, z, {
+		...V,
+		path: [
+			...V.path,
+			U ? "oneOf" : "anyOf",
+			B
+		]
+	}));
+	U ? B.oneOf = W : B.anyOf = W;
+}, intersectionProcessor = (u, z, B, V) => {
+	let H = u._zod.def, U = process$1(H.left, z, {
+		...V,
+		path: [
+			...V.path,
+			"allOf",
+			0
+		]
+	}), W = process$1(H.right, z, {
+		...V,
+		path: [
+			...V.path,
+			"allOf",
+			1
+		]
+	}), G = (u) => "allOf" in u && Object.keys(u).length === 1;
+	B.allOf = [...G(U) ? U.allOf : [U], ...G(W) ? W.allOf : [W]];
+}, recordProcessor = (u, z, B, V) => {
+	let H = B, U = u._zod.def;
+	H.type = "object";
+	let W = U.keyType, G = W._zod.bag?.patterns;
+	if (U.mode === "loose" && G && G.size > 0) {
+		let u = process$1(U.valueType, z, {
+			...V,
+			path: [
+				...V.path,
+				"patternProperties",
+				"*"
+			]
+		});
+		H.patternProperties = {};
+		for (let z of G) H.patternProperties[z.source] = u;
+	} else (z.target === "draft-07" || z.target === "draft-2020-12") && (H.propertyNames = process$1(U.keyType, z, {
+		...V,
+		path: [...V.path, "propertyNames"]
+	})), H.additionalProperties = process$1(U.valueType, z, {
+		...V,
+		path: [...V.path, "additionalProperties"]
+	});
+	let K = W._zod.values;
+	if (K) {
+		let u = [...K].filter((u) => typeof u == "string" || typeof u == "number");
+		u.length > 0 && (H.required = u);
+	}
+}, nullableProcessor = (u, z, B, V) => {
+	let H = u._zod.def, U = process$1(H.innerType, z, V), W = z.seen.get(u);
+	z.target === "openapi-3.0" ? (W.ref = H.innerType, B.nullable = !0) : B.anyOf = [U, { type: "null" }];
+}, nonoptionalProcessor = (u, z, B, V) => {
+	let H = u._zod.def;
+	process$1(H.innerType, z, V);
+	let U = z.seen.get(u);
+	U.ref = H.innerType;
+}, defaultProcessor = (u, z, B, V) => {
+	let H = u._zod.def;
+	process$1(H.innerType, z, V);
+	let U = z.seen.get(u);
+	U.ref = H.innerType, B.default = JSON.parse(JSON.stringify(H.defaultValue));
+}, prefaultProcessor = (u, z, B, V) => {
+	let H = u._zod.def;
+	process$1(H.innerType, z, V);
+	let U = z.seen.get(u);
+	U.ref = H.innerType, z.io === "input" && (B._prefault = JSON.parse(JSON.stringify(H.defaultValue)));
+}, catchProcessor = (u, z, B, V) => {
+	let H = u._zod.def;
+	process$1(H.innerType, z, V);
+	let U = z.seen.get(u);
+	U.ref = H.innerType;
+	let W;
+	try {
+		W = H.catchValue(void 0);
+	} catch {
+		throw Error("Dynamic catch values are not supported in JSON Schema");
+	}
+	B.default = W;
+}, pipeProcessor = (u, z, B, V) => {
+	let H = u._zod.def, U = H.in._zod.traits.has("$ZodTransform"), W = z.io === "input" ? U ? H.out : H.in : H.out;
+	process$1(W, z, V);
+	let G = z.seen.get(u);
+	G.ref = W;
+}, readonlyProcessor = (u, z, B, V) => {
+	let H = u._zod.def;
+	process$1(H.innerType, z, V);
+	let U = z.seen.get(u);
+	U.ref = H.innerType, B.readOnly = !0;
+}, optionalProcessor = (u, z, B, V) => {
+	let H = u._zod.def;
+	process$1(H.innerType, z, V);
+	let U = z.seen.get(u);
+	U.ref = H.innerType;
+}, ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (u, z) => {
+	$ZodISODateTime.init(u, z), ZodStringFormat.init(u, z);
+});
+function datetime(u) {
+	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, u);
+}
+const ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (u, z) => {
+	$ZodISODate.init(u, z), ZodStringFormat.init(u, z);
+});
+function date(u) {
+	return /* @__PURE__ */ _isoDate(ZodISODate, u);
+}
+const ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (u, z) => {
+	$ZodISOTime.init(u, z), ZodStringFormat.init(u, z);
+});
+function time(u) {
+	return /* @__PURE__ */ _isoTime(ZodISOTime, u);
+}
+const ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (u, z) => {
+	$ZodISODuration.init(u, z), ZodStringFormat.init(u, z);
+});
+function duration(u) {
+	return /* @__PURE__ */ _isoDuration(ZodISODuration, u);
+}
+const ZodRealError = /* @__PURE__ */ $constructor("ZodError", (u, z) => {
+	$ZodError.init(u, z), u.name = "ZodError", Object.defineProperties(u, {
+		format: { value: (z) => formatError(u, z) },
+		flatten: { value: (z) => flattenError(u, z) },
+		addIssue: { value: (z) => {
+			u.issues.push(z), u.message = JSON.stringify(u.issues, jsonStringifyReplacer, 2);
+		} },
+		addIssues: { value: (z) => {
+			u.issues.push(...z), u.message = JSON.stringify(u.issues, jsonStringifyReplacer, 2);
+		} },
+		isEmpty: { get() {
+			return u.issues.length === 0;
+		} }
+	});
+}, { Parent: Error }), parse = /* @__PURE__ */ _parse(ZodRealError), parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError), safeParse = /* @__PURE__ */ _safeParse(ZodRealError), safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError), encode = /* @__PURE__ */ _encode(ZodRealError), decode = /* @__PURE__ */ _decode(ZodRealError), encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError), decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError), safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError), safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError), safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError), safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
+var _installedGroups = /* @__PURE__ */ new WeakMap();
+function _installLazyMethods(u, z, B) {
+	let V = Object.getPrototypeOf(u), H = _installedGroups.get(V);
+	if (H || (H = /* @__PURE__ */ new Set(), _installedGroups.set(V, H)), !H.has(z)) for (let u in H.add(z), B) {
+		let z = B[u];
+		Object.defineProperty(V, u, {
+			configurable: !0,
+			enumerable: !1,
+			get() {
+				let B = z.bind(this);
+				return Object.defineProperty(this, u, {
+					configurable: !0,
+					writable: !0,
+					enumerable: !0,
+					value: B
+				}), B;
+			},
+			set(z) {
+				Object.defineProperty(this, u, {
+					configurable: !0,
+					writable: !0,
+					enumerable: !0,
+					value: z
+				});
+			}
+		});
+	}
+}
+const ZodType = /* @__PURE__ */ $constructor("ZodType", (u, z) => ($ZodType.init(u, z), Object.assign(u["~standard"], { jsonSchema: {
+	input: createStandardJSONSchemaMethod(u, "input"),
+	output: createStandardJSONSchemaMethod(u, "output")
+} }), u.toJSONSchema = createToJSONSchemaMethod(u, {}), u.def = z, u.type = z.type, Object.defineProperty(u, "_def", { value: z }), u.parse = (z, B) => parse(u, z, B, { callee: u.parse }), u.safeParse = (z, B) => safeParse(u, z, B), u.parseAsync = async (z, B) => parseAsync(u, z, B, { callee: u.parseAsync }), u.safeParseAsync = async (z, B) => safeParseAsync(u, z, B), u.spa = u.safeParseAsync, u.encode = (z, B) => encode(u, z, B), u.decode = (z, B) => decode(u, z, B), u.encodeAsync = async (z, B) => encodeAsync(u, z, B), u.decodeAsync = async (z, B) => decodeAsync(u, z, B), u.safeEncode = (z, B) => safeEncode(u, z, B), u.safeDecode = (z, B) => safeDecode(u, z, B), u.safeEncodeAsync = async (z, B) => safeEncodeAsync(u, z, B), u.safeDecodeAsync = async (z, B) => safeDecodeAsync(u, z, B), _installLazyMethods(u, "ZodType", {
+	check(...u) {
+		let z = this.def;
+		return this.clone(mergeDefs(z, { checks: [...z.checks ?? [], ...u.map((u) => typeof u == "function" ? { _zod: {
+			check: u,
+			def: { check: "custom" },
+			onattach: []
+		} } : u)] }), { parent: !0 });
+	},
+	with(...u) {
+		return this.check(...u);
+	},
+	clone(u, z) {
+		return clone(this, u, z);
+	},
+	brand() {
+		return this;
+	},
+	register(u, z) {
+		return u.add(this, z), this;
+	},
+	refine(u, z) {
+		return this.check(refine(u, z));
+	},
+	superRefine(u, z) {
+		return this.check(superRefine(u, z));
+	},
+	overwrite(u) {
+		return this.check(/* @__PURE__ */ _overwrite(u));
+	},
+	optional() {
+		return optional(this);
+	},
+	exactOptional() {
+		return exactOptional(this);
+	},
+	nullable() {
+		return nullable(this);
+	},
+	nullish() {
+		return optional(nullable(this));
+	},
+	nonoptional(u) {
+		return nonoptional(this, u);
+	},
+	array() {
+		return array(this);
+	},
+	or(u) {
+		return union([this, u]);
+	},
+	and(u) {
+		return intersection(this, u);
+	},
+	transform(u) {
+		return pipe(this, transform(u));
+	},
+	default(u) {
+		return _default(this, u);
+	},
+	prefault(u) {
+		return prefault(this, u);
+	},
+	catch(u) {
+		return _catch(this, u);
+	},
+	pipe(u) {
+		return pipe(this, u);
+	},
+	readonly() {
+		return readonly(this);
+	},
+	describe(u) {
+		let z = this.clone();
+		return globalRegistry.add(z, { description: u }), z;
+	},
+	meta(...u) {
+		if (u.length === 0) return globalRegistry.get(this);
+		let z = this.clone();
+		return globalRegistry.add(z, u[0]), z;
+	},
+	isOptional() {
+		return this.safeParse(void 0).success;
+	},
+	isNullable() {
+		return this.safeParse(null).success;
+	},
+	apply(u) {
+		return u(this);
+	}
+}), Object.defineProperty(u, "description", {
+	get() {
+		return globalRegistry.get(u)?.description;
+	},
+	configurable: !0
+}), u)), _ZodString = /* @__PURE__ */ $constructor("_ZodString", (u, z) => {
+	$ZodString.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => stringProcessor(u, z, B, V);
+	let B = u._zod.bag;
+	u.format = B.format ?? null, u.minLength = B.minimum ?? null, u.maxLength = B.maximum ?? null, _installLazyMethods(u, "_ZodString", {
+		regex(...u) {
+			return this.check(/* @__PURE__ */ _regex(...u));
+		},
+		includes(...u) {
+			return this.check(/* @__PURE__ */ _includes(...u));
+		},
+		startsWith(...u) {
+			return this.check(/* @__PURE__ */ _startsWith(...u));
+		},
+		endsWith(...u) {
+			return this.check(/* @__PURE__ */ _endsWith(...u));
+		},
+		min(...u) {
+			return this.check(/* @__PURE__ */ _minLength(...u));
+		},
+		max(...u) {
+			return this.check(/* @__PURE__ */ _maxLength(...u));
+		},
+		length(...u) {
+			return this.check(/* @__PURE__ */ _length(...u));
+		},
+		nonempty(...u) {
+			return this.check(/* @__PURE__ */ _minLength(1, ...u));
+		},
+		lowercase(u) {
+			return this.check(/* @__PURE__ */ _lowercase(u));
+		},
+		uppercase(u) {
+			return this.check(/* @__PURE__ */ _uppercase(u));
+		},
+		trim() {
+			return this.check(/* @__PURE__ */ _trim());
+		},
+		normalize(...u) {
+			return this.check(/* @__PURE__ */ _normalize(...u));
+		},
+		toLowerCase() {
+			return this.check(/* @__PURE__ */ _toLowerCase());
+		},
+		toUpperCase() {
+			return this.check(/* @__PURE__ */ _toUpperCase());
+		},
+		slugify() {
+			return this.check(/* @__PURE__ */ _slugify());
+		}
+	});
+}), ZodString = /* @__PURE__ */ $constructor("ZodString", (u, z) => {
+	$ZodString.init(u, z), _ZodString.init(u, z), u.email = (z) => u.check(/* @__PURE__ */ _email(ZodEmail, z)), u.url = (z) => u.check(/* @__PURE__ */ _url(ZodURL, z)), u.jwt = (z) => u.check(/* @__PURE__ */ _jwt(ZodJWT, z)), u.emoji = (z) => u.check(/* @__PURE__ */ _emoji(ZodEmoji, z)), u.guid = (z) => u.check(/* @__PURE__ */ _guid(ZodGUID, z)), u.uuid = (z) => u.check(/* @__PURE__ */ _uuid(ZodUUID, z)), u.uuidv4 = (z) => u.check(/* @__PURE__ */ _uuidv4(ZodUUID, z)), u.uuidv6 = (z) => u.check(/* @__PURE__ */ _uuidv6(ZodUUID, z)), u.uuidv7 = (z) => u.check(/* @__PURE__ */ _uuidv7(ZodUUID, z)), u.nanoid = (z) => u.check(/* @__PURE__ */ _nanoid(ZodNanoID, z)), u.guid = (z) => u.check(/* @__PURE__ */ _guid(ZodGUID, z)), u.cuid = (z) => u.check(/* @__PURE__ */ _cuid(ZodCUID, z)), u.cuid2 = (z) => u.check(/* @__PURE__ */ _cuid2(ZodCUID2, z)), u.ulid = (z) => u.check(/* @__PURE__ */ _ulid(ZodULID, z)), u.base64 = (z) => u.check(/* @__PURE__ */ _base64(ZodBase64, z)), u.base64url = (z) => u.check(/* @__PURE__ */ _base64url(ZodBase64URL, z)), u.xid = (z) => u.check(/* @__PURE__ */ _xid(ZodXID, z)), u.ksuid = (z) => u.check(/* @__PURE__ */ _ksuid(ZodKSUID, z)), u.ipv4 = (z) => u.check(/* @__PURE__ */ _ipv4(ZodIPv4, z)), u.ipv6 = (z) => u.check(/* @__PURE__ */ _ipv6(ZodIPv6, z)), u.cidrv4 = (z) => u.check(/* @__PURE__ */ _cidrv4(ZodCIDRv4, z)), u.cidrv6 = (z) => u.check(/* @__PURE__ */ _cidrv6(ZodCIDRv6, z)), u.e164 = (z) => u.check(/* @__PURE__ */ _e164(ZodE164, z)), u.datetime = (z) => u.check(datetime(z)), u.date = (z) => u.check(date(z)), u.time = (z) => u.check(time(z)), u.duration = (z) => u.check(duration(z));
+});
+function string(u) {
+	return /* @__PURE__ */ _string(ZodString, u);
+}
+const ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (u, z) => {
+	$ZodStringFormat.init(u, z), _ZodString.init(u, z);
+}), ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (u, z) => {
+	$ZodEmail.init(u, z), ZodStringFormat.init(u, z);
+}), ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (u, z) => {
+	$ZodGUID.init(u, z), ZodStringFormat.init(u, z);
+}), ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (u, z) => {
+	$ZodUUID.init(u, z), ZodStringFormat.init(u, z);
+}), ZodURL = /* @__PURE__ */ $constructor("ZodURL", (u, z) => {
+	$ZodURL.init(u, z), ZodStringFormat.init(u, z);
+}), ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (u, z) => {
+	$ZodEmoji.init(u, z), ZodStringFormat.init(u, z);
+}), ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (u, z) => {
+	$ZodNanoID.init(u, z), ZodStringFormat.init(u, z);
+}), ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (u, z) => {
+	$ZodCUID.init(u, z), ZodStringFormat.init(u, z);
+}), ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (u, z) => {
+	$ZodCUID2.init(u, z), ZodStringFormat.init(u, z);
+}), ZodULID = /* @__PURE__ */ $constructor("ZodULID", (u, z) => {
+	$ZodULID.init(u, z), ZodStringFormat.init(u, z);
+}), ZodXID = /* @__PURE__ */ $constructor("ZodXID", (u, z) => {
+	$ZodXID.init(u, z), ZodStringFormat.init(u, z);
+}), ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (u, z) => {
+	$ZodKSUID.init(u, z), ZodStringFormat.init(u, z);
+}), ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (u, z) => {
+	$ZodIPv4.init(u, z), ZodStringFormat.init(u, z);
+}), ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (u, z) => {
+	$ZodIPv6.init(u, z), ZodStringFormat.init(u, z);
+}), ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (u, z) => {
+	$ZodCIDRv4.init(u, z), ZodStringFormat.init(u, z);
+}), ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (u, z) => {
+	$ZodCIDRv6.init(u, z), ZodStringFormat.init(u, z);
+}), ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (u, z) => {
+	$ZodBase64.init(u, z), ZodStringFormat.init(u, z);
+}), ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (u, z) => {
+	$ZodBase64URL.init(u, z), ZodStringFormat.init(u, z);
+}), ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (u, z) => {
+	$ZodE164.init(u, z), ZodStringFormat.init(u, z);
+}), ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (u, z) => {
+	$ZodJWT.init(u, z), ZodStringFormat.init(u, z);
+}), ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (u, z) => {
+	$ZodUnknown.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (u, z, B) => void 0;
+});
+function unknown() {
+	return /* @__PURE__ */ _unknown(ZodUnknown);
+}
+const ZodNever = /* @__PURE__ */ $constructor("ZodNever", (u, z) => {
+	$ZodNever.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => neverProcessor(u, z, B, V);
+});
+function never(u) {
+	return /* @__PURE__ */ _never(ZodNever, u);
+}
+const ZodArray = /* @__PURE__ */ $constructor("ZodArray", (u, z) => {
+	$ZodArray.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => arrayProcessor(u, z, B, V), u.element = z.element, _installLazyMethods(u, "ZodArray", {
+		min(u, z) {
+			return this.check(/* @__PURE__ */ _minLength(u, z));
+		},
+		nonempty(u) {
+			return this.check(/* @__PURE__ */ _minLength(1, u));
+		},
+		max(u, z) {
+			return this.check(/* @__PURE__ */ _maxLength(u, z));
+		},
+		length(u, z) {
+			return this.check(/* @__PURE__ */ _length(u, z));
+		},
+		unwrap() {
+			return this.element;
+		}
+	});
+});
+function array(u, z) {
+	return /* @__PURE__ */ _array(ZodArray, u, z);
+}
+const ZodObject = /* @__PURE__ */ $constructor("ZodObject", (u, z) => {
+	$ZodObjectJIT.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => objectProcessor(u, z, B, V), defineLazy(u, "shape", () => z.shape), _installLazyMethods(u, "ZodObject", {
+		keyof() {
+			return _enum(Object.keys(this._zod.def.shape));
+		},
+		catchall(u) {
+			return this.clone({
+				...this._zod.def,
+				catchall: u
+			});
+		},
+		passthrough() {
+			return this.clone({
+				...this._zod.def,
+				catchall: unknown()
+			});
+		},
+		loose() {
+			return this.clone({
+				...this._zod.def,
+				catchall: unknown()
+			});
+		},
+		strict() {
+			return this.clone({
+				...this._zod.def,
+				catchall: never()
+			});
+		},
+		strip() {
+			return this.clone({
+				...this._zod.def,
+				catchall: void 0
+			});
+		},
+		extend(u) {
+			return extend(this, u);
+		},
+		safeExtend(u) {
+			return safeExtend(this, u);
+		},
+		merge(u) {
+			return merge(this, u);
+		},
+		pick(u) {
+			return pick(this, u);
+		},
+		omit(u) {
+			return omit(this, u);
+		},
+		partial(...u) {
+			return partial(ZodOptional, this, u[0]);
+		},
+		required(...u) {
+			return required(ZodNonOptional, this, u[0]);
+		}
+	});
+});
+function object(u, z) {
+	return new ZodObject({
+		type: "object",
+		shape: u ?? {},
+		...normalizeParams(z)
+	});
+}
+const ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (u, z) => {
+	$ZodUnion.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => unionProcessor(u, z, B, V), u.options = z.options;
+});
+function union(u, z) {
+	return new ZodUnion({
+		type: "union",
+		options: u,
+		...normalizeParams(z)
+	});
+}
+const ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (u, z) => {
+	$ZodIntersection.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => intersectionProcessor(u, z, B, V);
+});
+function intersection(u, z) {
+	return new ZodIntersection({
+		type: "intersection",
+		left: u,
+		right: z
+	});
+}
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (u, z) => {
+	$ZodRecord.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => recordProcessor(u, z, B, V), u.keyType = z.keyType, u.valueType = z.valueType;
+});
+function record(u, z, B) {
+	return !z || !z._zod ? new ZodRecord({
+		type: "record",
+		keyType: string(),
+		valueType: u,
+		...normalizeParams(z)
+	}) : new ZodRecord({
+		type: "record",
+		keyType: u,
+		valueType: z,
+		...normalizeParams(B)
+	});
+}
+const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (u, z) => {
+	$ZodEnum.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => enumProcessor(u, z, B, V), u.enum = z.entries, u.options = Object.values(z.entries);
+	let B = new Set(Object.keys(z.entries));
+	u.extract = (u, V) => {
+		let H = {};
+		for (let V of u) if (B.has(V)) H[V] = z.entries[V];
+		else throw Error(`Key ${V} not found in enum`);
+		return new ZodEnum({
+			...z,
+			checks: [],
+			...normalizeParams(V),
+			entries: H
+		});
+	}, u.exclude = (u, V) => {
+		let H = { ...z.entries };
+		for (let z of u) if (B.has(z)) delete H[z];
+		else throw Error(`Key ${z} not found in enum`);
+		return new ZodEnum({
+			...z,
+			checks: [],
+			...normalizeParams(V),
+			entries: H
+		});
+	};
+});
+function _enum(u, z) {
+	return new ZodEnum({
+		type: "enum",
+		entries: Array.isArray(u) ? Object.fromEntries(u.map((u) => [u, u])) : u,
+		...normalizeParams(z)
+	});
+}
+const ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (u, z) => {
+	$ZodTransform.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => transformProcessor(u, z, B, V), u._zod.parse = (B, V) => {
+		if (V.direction === "backward") throw new $ZodEncodeError(u.constructor.name);
+		B.addIssue = (V) => {
+			if (typeof V == "string") B.issues.push(issue(V, B.value, z));
+			else {
+				let z = V;
+				z.fatal && (z.continue = !1), z.code ??= "custom", z.input ??= B.value, z.inst ??= u, B.issues.push(issue(z));
+			}
+		};
+		let H = z.transform(B.value, B);
+		return H instanceof Promise ? H.then((u) => (B.value = u, B.fallback = !0, B)) : (B.value = H, B.fallback = !0, B);
+	};
+});
+function transform(u) {
+	return new ZodTransform({
+		type: "transform",
+		transform: u
+	});
+}
+const ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (u, z) => {
+	$ZodOptional.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => optionalProcessor(u, z, B, V), u.unwrap = () => u._zod.def.innerType;
+});
+function optional(u) {
+	return new ZodOptional({
+		type: "optional",
+		innerType: u
+	});
+}
+const ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (u, z) => {
+	$ZodExactOptional.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => optionalProcessor(u, z, B, V), u.unwrap = () => u._zod.def.innerType;
+});
+function exactOptional(u) {
+	return new ZodExactOptional({
+		type: "optional",
+		innerType: u
+	});
+}
+const ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (u, z) => {
+	$ZodNullable.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => nullableProcessor(u, z, B, V), u.unwrap = () => u._zod.def.innerType;
+});
+function nullable(u) {
+	return new ZodNullable({
+		type: "nullable",
+		innerType: u
+	});
+}
+const ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (u, z) => {
+	$ZodDefault.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => defaultProcessor(u, z, B, V), u.unwrap = () => u._zod.def.innerType, u.removeDefault = u.unwrap;
+});
+function _default(u, z) {
+	return new ZodDefault({
+		type: "default",
+		innerType: u,
+		get defaultValue() {
+			return typeof z == "function" ? z() : shallowClone(z);
+		}
+	});
+}
+const ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (u, z) => {
+	$ZodPrefault.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => prefaultProcessor(u, z, B, V), u.unwrap = () => u._zod.def.innerType;
+});
+function prefault(u, z) {
+	return new ZodPrefault({
+		type: "prefault",
+		innerType: u,
+		get defaultValue() {
+			return typeof z == "function" ? z() : shallowClone(z);
+		}
+	});
+}
+const ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (u, z) => {
+	$ZodNonOptional.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => nonoptionalProcessor(u, z, B, V), u.unwrap = () => u._zod.def.innerType;
+});
+function nonoptional(u, z) {
+	return new ZodNonOptional({
+		type: "nonoptional",
+		innerType: u,
+		...normalizeParams(z)
+	});
+}
+const ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (u, z) => {
+	$ZodCatch.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => catchProcessor(u, z, B, V), u.unwrap = () => u._zod.def.innerType, u.removeCatch = u.unwrap;
+});
+function _catch(u, z) {
+	return new ZodCatch({
+		type: "catch",
+		innerType: u,
+		catchValue: typeof z == "function" ? z : () => z
+	});
+}
+const ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (u, z) => {
+	$ZodPipe.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => pipeProcessor(u, z, B, V), u.in = z.in, u.out = z.out;
+});
+function pipe(u, z) {
+	return new ZodPipe({
+		type: "pipe",
+		in: u,
+		out: z
+	});
+}
+const ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (u, z) => {
+	$ZodReadonly.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => readonlyProcessor(u, z, B, V), u.unwrap = () => u._zod.def.innerType;
+});
+function readonly(u) {
+	return new ZodReadonly({
+		type: "readonly",
+		innerType: u
+	});
+}
+const ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (u, z) => {
+	$ZodCustom.init(u, z), ZodType.init(u, z), u._zod.processJSONSchema = (z, B, V) => customProcessor(u, z, B, V);
+});
+function refine(u, z = {}) {
+	return /* @__PURE__ */ _refine(ZodCustom, u, z);
+}
+function superRefine(u, z) {
+	return /* @__PURE__ */ _superRefine(u, z);
+}
+export { Subscribable as A, resolveStaleTime as C, timeUntilStale as D, skipToken as E, client as M, timeoutManager as O, resolveQueryBoolean as S, shouldThrowError as T, matchMutation as _, Mutation as a, partialMatchKey as b, fetchState as c, pendingThenable as d, environmentManager as f, isValidTimeout as g, hashQueryKeyByOptions as h, string as i, Client as j, focusManager as k, onlineManager as l, hashKey as m, object as n, getDefaultState as o, functionalUpdate as p, record as r, Query as s, _enum as t, notifyManager as u, matchQuery as v, shallowEqualObjects as w, replaceData as x, noop as y };