@burdenoff/microfe-admin 2026.511.1

package/dist/node_modules/zod/v3/types.js

@@ -0,0 +1,2459 @@
+import { ZodParsedType as e, getParsedType as t, util as n } from "./helpers/util.js";
+import { ZodError as r, ZodIssueCode as i } from "./ZodError.js";
+import a from "./locales/en.js";
+import { getErrorMap as o } from "./errors.js";
+import { DIRTY as s, INVALID as c, OK as l, ParseStatus as u, addIssueToContext as d, isAborted as f, isAsync as p, isDirty as ee, isValid as m, makeIssue as te } from "./helpers/parseUtil.js";
+import { errorUtil as h } from "./helpers/errorUtil.js";
+//#region node_modules/zod/v3/types.js
+var g = class {
+	constructor(e, t, n, r) {
+		this._cachedPath = [], this.parent = e, this.data = t, this._path = n, this._key = r;
+	}
+	get path() {
+		return this._cachedPath.length || (Array.isArray(this._key) ? this._cachedPath.push(...this._path, ...this._key) : this._cachedPath.push(...this._path, this._key)), this._cachedPath;
+	}
+}, ne = (e, t) => {
+	if (m(t)) return {
+		success: !0,
+		data: t.value
+	};
+	if (!e.common.issues.length) throw Error("Validation failed but no issues detected.");
+	return {
+		success: !1,
+		get error() {
+			return this._error ||= new r(e.common.issues), this._error;
+		}
+	};
+};
+function _(e) {
+	if (!e) return {};
+	let { errorMap: t, invalid_type_error: n, required_error: r, description: i } = e;
+	if (t && (n || r)) throw Error("Can't use \"invalid_type_error\" or \"required_error\" in conjunction with custom error map.");
+	return t ? {
+		errorMap: t,
+		description: i
+	} : {
+		errorMap: (t, i) => {
+			let { message: a } = e;
+			return t.code === "invalid_enum_value" ? { message: a ?? i.defaultError } : i.data === void 0 ? { message: a ?? r ?? i.defaultError } : t.code === "invalid_type" ? { message: a ?? n ?? i.defaultError } : { message: i.defaultError };
+		},
+		description: i
+	};
+}
+var v = class {
+	get description() {
+		return this._def.description;
+	}
+	_getType(e) {
+		return t(e.data);
+	}
+	_getOrReturnCtx(e, n) {
+		return n || {
+			common: e.parent.common,
+			data: e.data,
+			parsedType: t(e.data),
+			schemaErrorMap: this._def.errorMap,
+			path: e.path,
+			parent: e.parent
+		};
+	}
+	_processInputParams(e) {
+		return {
+			status: new u(),
+			ctx: {
+				common: e.parent.common,
+				data: e.data,
+				parsedType: t(e.data),
+				schemaErrorMap: this._def.errorMap,
+				path: e.path,
+				parent: e.parent
+			}
+		};
+	}
+	_parseSync(e) {
+		let t = this._parse(e);
+		if (p(t)) throw Error("Synchronous parse encountered promise.");
+		return t;
+	}
+	_parseAsync(e) {
+		let t = this._parse(e);
+		return Promise.resolve(t);
+	}
+	parse(e, t) {
+		let n = this.safeParse(e, t);
+		if (n.success) return n.data;
+		throw n.error;
+	}
+	safeParse(e, n) {
+		let r = {
+			common: {
+				issues: [],
+				async: n?.async ?? !1,
+				contextualErrorMap: n?.errorMap
+			},
+			path: n?.path || [],
+			schemaErrorMap: this._def.errorMap,
+			parent: null,
+			data: e,
+			parsedType: t(e)
+		};
+		return ne(r, this._parseSync({
+			data: e,
+			path: r.path,
+			parent: r
+		}));
+	}
+	"~validate"(e) {
+		let n = {
+			common: {
+				issues: [],
+				async: !!this["~standard"].async
+			},
+			path: [],
+			schemaErrorMap: this._def.errorMap,
+			parent: null,
+			data: e,
+			parsedType: t(e)
+		};
+		if (!this["~standard"].async) try {
+			let t = this._parseSync({
+				data: e,
+				path: [],
+				parent: n
+			});
+			return m(t) ? { value: t.value } : { issues: n.common.issues };
+		} catch (e) {
+			e?.message?.toLowerCase()?.includes("encountered") && (this["~standard"].async = !0), n.common = {
+				issues: [],
+				async: !0
+			};
+		}
+		return this._parseAsync({
+			data: e,
+			path: [],
+			parent: n
+		}).then((e) => m(e) ? { value: e.value } : { issues: n.common.issues });
+	}
+	async parseAsync(e, t) {
+		let n = await this.safeParseAsync(e, t);
+		if (n.success) return n.data;
+		throw n.error;
+	}
+	async safeParseAsync(e, n) {
+		let r = {
+			common: {
+				issues: [],
+				contextualErrorMap: n?.errorMap,
+				async: !0
+			},
+			path: n?.path || [],
+			schemaErrorMap: this._def.errorMap,
+			parent: null,
+			data: e,
+			parsedType: t(e)
+		}, i = this._parse({
+			data: e,
+			path: r.path,
+			parent: r
+		});
+		return ne(r, await (p(i) ? i : Promise.resolve(i)));
+	}
+	refine(e, t) {
+		let n = (e) => typeof t == "string" || t === void 0 ? { message: t } : typeof t == "function" ? t(e) : t;
+		return this._refinement((t, r) => {
+			let a = e(t), o = () => r.addIssue({
+				code: i.custom,
+				...n(t)
+			});
+			return typeof Promise < "u" && a instanceof Promise ? a.then((e) => e ? !0 : (o(), !1)) : a ? !0 : (o(), !1);
+		});
+	}
+	refinement(e, t) {
+		return this._refinement((n, r) => e(n) ? !0 : (r.addIssue(typeof t == "function" ? t(n, r) : t), !1));
+	}
+	_refinement(e) {
+		return new K({
+			schema: this,
+			typeName: $.ZodEffects,
+			effect: {
+				type: "refinement",
+				refinement: e
+			}
+		});
+	}
+	superRefine(e) {
+		return this._refinement(e);
+	}
+	constructor(e) {
+		this.spa = this.safeParseAsync, this._def = e, this.parse = this.parse.bind(this), this.safeParse = this.safeParse.bind(this), this.parseAsync = this.parseAsync.bind(this), this.safeParseAsync = this.safeParseAsync.bind(this), this.spa = this.spa.bind(this), this.refine = this.refine.bind(this), this.refinement = this.refinement.bind(this), this.superRefine = this.superRefine.bind(this), this.optional = this.optional.bind(this), this.nullable = this.nullable.bind(this), this.nullish = this.nullish.bind(this), this.array = this.array.bind(this), this.promise = this.promise.bind(this), this.or = this.or.bind(this), this.and = this.and.bind(this), this.transform = this.transform.bind(this), this.brand = this.brand.bind(this), this.default = this.default.bind(this), this.catch = this.catch.bind(this), this.describe = this.describe.bind(this), this.pipe = this.pipe.bind(this), this.readonly = this.readonly.bind(this), this.isNullable = this.isNullable.bind(this), this.isOptional = this.isOptional.bind(this), this["~standard"] = {
+			version: 1,
+			vendor: "zod",
+			validate: (e) => this["~validate"](e)
+		};
+	}
+	optional() {
+		return q.create(this, this._def);
+	}
+	nullable() {
+		return J.create(this, this._def);
+	}
+	nullish() {
+		return this.nullable().optional();
+	}
+	array() {
+		return j.create(this);
+	}
+	promise() {
+		return G.create(this, this._def);
+	}
+	or(e) {
+		return P.create([this, e], this._def);
+	}
+	and(e) {
+		return L.create(this, e, this._def);
+	}
+	transform(e) {
+		return new K({
+			..._(this._def),
+			schema: this,
+			typeName: $.ZodEffects,
+			effect: {
+				type: "transform",
+				transform: e
+			}
+		});
+	}
+	default(e) {
+		let t = typeof e == "function" ? e : () => e;
+		return new Y({
+			..._(this._def),
+			innerType: this,
+			defaultValue: t,
+			typeName: $.ZodDefault
+		});
+	}
+	brand() {
+		return new Me({
+			typeName: $.ZodBranded,
+			type: this,
+			..._(this._def)
+		});
+	}
+	catch(e) {
+		let t = typeof e == "function" ? e : () => e;
+		return new X({
+			..._(this._def),
+			innerType: this,
+			catchValue: t,
+			typeName: $.ZodCatch
+		});
+	}
+	describe(e) {
+		let t = this.constructor;
+		return new t({
+			...this._def,
+			description: e
+		});
+	}
+	pipe(e) {
+		return Ne.create(this, e);
+	}
+	readonly() {
+		return Q.create(this);
+	}
+	isOptional() {
+		return this.safeParse(void 0).success;
+	}
+	isNullable() {
+		return this.safeParse(null).success;
+	}
+}, re = /^c[^\s-]{8,}$/i, ie = /^[0-9a-z]+$/, ae = /^[0-9A-HJKMNP-TV-Z]{26}$/i, oe = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i, se = /^[a-z0-9_-]{21}$/i, ce = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/, le = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/, ue = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i, de = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", fe, pe = /^(?:(?: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])$/, me = /^(?:(?: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])\/(3[0-2]|[12]?[0-9])$/, he = /^(([0-9a-fA-F]{1,4}:){7,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}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/, ge = /^(([0-9a-fA-F]{1,4}:){7,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}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/, _e = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/, ve = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/, ye = "((\\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])))", be = RegExp(`^${ye}$`);
+function xe(e) {
+	let t = "[0-5]\\d";
+	e.precision ? t = `${t}\\.\\d{${e.precision}}` : e.precision ?? (t = `${t}(\\.\\d+)?`);
+	let n = e.precision ? "+" : "?";
+	return `([01]\\d|2[0-3]):[0-5]\\d(:${t})${n}`;
+}
+function Se(e) {
+	return RegExp(`^${xe(e)}$`);
+}
+function Ce(e) {
+	let t = `${ye}T${xe(e)}`, n = [];
+	return n.push(e.local ? "Z?" : "Z"), e.offset && n.push("([+-]\\d{2}:?\\d{2})"), t = `${t}(${n.join("|")})`, RegExp(`^${t}$`);
+}
+function we(e, t) {
+	return !!((t === "v4" || !t) && pe.test(e) || (t === "v6" || !t) && he.test(e));
+}
+function Te(e, t) {
+	if (!ce.test(e)) return !1;
+	try {
+		let [n] = e.split(".");
+		if (!n) return !1;
+		let r = n.replace(/-/g, "+").replace(/_/g, "/").padEnd(n.length + (4 - n.length % 4) % 4, "="), i = JSON.parse(atob(r));
+		return !(typeof i != "object" || !i || "typ" in i && i?.typ !== "JWT" || !i.alg || t && i.alg !== t);
+	} catch {
+		return !1;
+	}
+}
+function Ee(e, t) {
+	return !!((t === "v4" || !t) && me.test(e) || (t === "v6" || !t) && ge.test(e));
+}
+var y = class t extends v {
+	_parse(t) {
+		if (this._def.coerce && (t.data = String(t.data)), this._getType(t) !== e.string) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.string,
+				received: n.parsedType
+			}), c;
+		}
+		let r = new u(), a;
+		for (let e of this._def.checks) if (e.kind === "min") t.data.length < e.value && (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.too_small,
+			minimum: e.value,
+			type: "string",
+			inclusive: !0,
+			exact: !1,
+			message: e.message
+		}), r.dirty());
+		else if (e.kind === "max") t.data.length > e.value && (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.too_big,
+			maximum: e.value,
+			type: "string",
+			inclusive: !0,
+			exact: !1,
+			message: e.message
+		}), r.dirty());
+		else if (e.kind === "length") {
+			let n = t.data.length > e.value, o = t.data.length < e.value;
+			(n || o) && (a = this._getOrReturnCtx(t, a), n ? d(a, {
+				code: i.too_big,
+				maximum: e.value,
+				type: "string",
+				inclusive: !0,
+				exact: !0,
+				message: e.message
+			}) : o && d(a, {
+				code: i.too_small,
+				minimum: e.value,
+				type: "string",
+				inclusive: !0,
+				exact: !0,
+				message: e.message
+			}), r.dirty());
+		} else if (e.kind === "email") ue.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "email",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty());
+		else if (e.kind === "emoji") fe ||= new RegExp(de, "u"), fe.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "emoji",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty());
+		else if (e.kind === "uuid") oe.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "uuid",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty());
+		else if (e.kind === "nanoid") se.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "nanoid",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty());
+		else if (e.kind === "cuid") re.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "cuid",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty());
+		else if (e.kind === "cuid2") ie.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "cuid2",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty());
+		else if (e.kind === "ulid") ae.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "ulid",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty());
+		else if (e.kind === "url") try {
+			new URL(t.data);
+		} catch {
+			a = this._getOrReturnCtx(t, a), d(a, {
+				validation: "url",
+				code: i.invalid_string,
+				message: e.message
+			}), r.dirty();
+		}
+		else e.kind === "regex" ? (e.regex.lastIndex = 0, e.regex.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "regex",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty())) : e.kind === "trim" ? t.data = t.data.trim() : e.kind === "includes" ? t.data.includes(e.value, e.position) || (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.invalid_string,
+			validation: {
+				includes: e.value,
+				position: e.position
+			},
+			message: e.message
+		}), r.dirty()) : e.kind === "toLowerCase" ? t.data = t.data.toLowerCase() : e.kind === "toUpperCase" ? t.data = t.data.toUpperCase() : e.kind === "startsWith" ? t.data.startsWith(e.value) || (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.invalid_string,
+			validation: { startsWith: e.value },
+			message: e.message
+		}), r.dirty()) : e.kind === "endsWith" ? t.data.endsWith(e.value) || (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.invalid_string,
+			validation: { endsWith: e.value },
+			message: e.message
+		}), r.dirty()) : e.kind === "datetime" ? Ce(e).test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.invalid_string,
+			validation: "datetime",
+			message: e.message
+		}), r.dirty()) : e.kind === "date" ? be.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.invalid_string,
+			validation: "date",
+			message: e.message
+		}), r.dirty()) : e.kind === "time" ? Se(e).test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.invalid_string,
+			validation: "time",
+			message: e.message
+		}), r.dirty()) : e.kind === "duration" ? le.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "duration",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty()) : e.kind === "ip" ? we(t.data, e.version) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "ip",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty()) : e.kind === "jwt" ? Te(t.data, e.alg) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "jwt",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty()) : e.kind === "cidr" ? Ee(t.data, e.version) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "cidr",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty()) : e.kind === "base64" ? _e.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "base64",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty()) : e.kind === "base64url" ? ve.test(t.data) || (a = this._getOrReturnCtx(t, a), d(a, {
+			validation: "base64url",
+			code: i.invalid_string,
+			message: e.message
+		}), r.dirty()) : n.assertNever(e);
+		return {
+			status: r.value,
+			value: t.data
+		};
+	}
+	_regex(e, t, n) {
+		return this.refinement((t) => e.test(t), {
+			validation: t,
+			code: i.invalid_string,
+			...h.errToObj(n)
+		});
+	}
+	_addCheck(e) {
+		return new t({
+			...this._def,
+			checks: [...this._def.checks, e]
+		});
+	}
+	email(e) {
+		return this._addCheck({
+			kind: "email",
+			...h.errToObj(e)
+		});
+	}
+	url(e) {
+		return this._addCheck({
+			kind: "url",
+			...h.errToObj(e)
+		});
+	}
+	emoji(e) {
+		return this._addCheck({
+			kind: "emoji",
+			...h.errToObj(e)
+		});
+	}
+	uuid(e) {
+		return this._addCheck({
+			kind: "uuid",
+			...h.errToObj(e)
+		});
+	}
+	nanoid(e) {
+		return this._addCheck({
+			kind: "nanoid",
+			...h.errToObj(e)
+		});
+	}
+	cuid(e) {
+		return this._addCheck({
+			kind: "cuid",
+			...h.errToObj(e)
+		});
+	}
+	cuid2(e) {
+		return this._addCheck({
+			kind: "cuid2",
+			...h.errToObj(e)
+		});
+	}
+	ulid(e) {
+		return this._addCheck({
+			kind: "ulid",
+			...h.errToObj(e)
+		});
+	}
+	base64(e) {
+		return this._addCheck({
+			kind: "base64",
+			...h.errToObj(e)
+		});
+	}
+	base64url(e) {
+		return this._addCheck({
+			kind: "base64url",
+			...h.errToObj(e)
+		});
+	}
+	jwt(e) {
+		return this._addCheck({
+			kind: "jwt",
+			...h.errToObj(e)
+		});
+	}
+	ip(e) {
+		return this._addCheck({
+			kind: "ip",
+			...h.errToObj(e)
+		});
+	}
+	cidr(e) {
+		return this._addCheck({
+			kind: "cidr",
+			...h.errToObj(e)
+		});
+	}
+	datetime(e) {
+		return typeof e == "string" ? this._addCheck({
+			kind: "datetime",
+			precision: null,
+			offset: !1,
+			local: !1,
+			message: e
+		}) : this._addCheck({
+			kind: "datetime",
+			precision: e?.precision === void 0 ? null : e?.precision,
+			offset: e?.offset ?? !1,
+			local: e?.local ?? !1,
+			...h.errToObj(e?.message)
+		});
+	}
+	date(e) {
+		return this._addCheck({
+			kind: "date",
+			message: e
+		});
+	}
+	time(e) {
+		return typeof e == "string" ? this._addCheck({
+			kind: "time",
+			precision: null,
+			message: e
+		}) : this._addCheck({
+			kind: "time",
+			precision: e?.precision === void 0 ? null : e?.precision,
+			...h.errToObj(e?.message)
+		});
+	}
+	duration(e) {
+		return this._addCheck({
+			kind: "duration",
+			...h.errToObj(e)
+		});
+	}
+	regex(e, t) {
+		return this._addCheck({
+			kind: "regex",
+			regex: e,
+			...h.errToObj(t)
+		});
+	}
+	includes(e, t) {
+		return this._addCheck({
+			kind: "includes",
+			value: e,
+			position: t?.position,
+			...h.errToObj(t?.message)
+		});
+	}
+	startsWith(e, t) {
+		return this._addCheck({
+			kind: "startsWith",
+			value: e,
+			...h.errToObj(t)
+		});
+	}
+	endsWith(e, t) {
+		return this._addCheck({
+			kind: "endsWith",
+			value: e,
+			...h.errToObj(t)
+		});
+	}
+	min(e, t) {
+		return this._addCheck({
+			kind: "min",
+			value: e,
+			...h.errToObj(t)
+		});
+	}
+	max(e, t) {
+		return this._addCheck({
+			kind: "max",
+			value: e,
+			...h.errToObj(t)
+		});
+	}
+	length(e, t) {
+		return this._addCheck({
+			kind: "length",
+			value: e,
+			...h.errToObj(t)
+		});
+	}
+	nonempty(e) {
+		return this.min(1, h.errToObj(e));
+	}
+	trim() {
+		return new t({
+			...this._def,
+			checks: [...this._def.checks, { kind: "trim" }]
+		});
+	}
+	toLowerCase() {
+		return new t({
+			...this._def,
+			checks: [...this._def.checks, { kind: "toLowerCase" }]
+		});
+	}
+	toUpperCase() {
+		return new t({
+			...this._def,
+			checks: [...this._def.checks, { kind: "toUpperCase" }]
+		});
+	}
+	get isDatetime() {
+		return !!this._def.checks.find((e) => e.kind === "datetime");
+	}
+	get isDate() {
+		return !!this._def.checks.find((e) => e.kind === "date");
+	}
+	get isTime() {
+		return !!this._def.checks.find((e) => e.kind === "time");
+	}
+	get isDuration() {
+		return !!this._def.checks.find((e) => e.kind === "duration");
+	}
+	get isEmail() {
+		return !!this._def.checks.find((e) => e.kind === "email");
+	}
+	get isURL() {
+		return !!this._def.checks.find((e) => e.kind === "url");
+	}
+	get isEmoji() {
+		return !!this._def.checks.find((e) => e.kind === "emoji");
+	}
+	get isUUID() {
+		return !!this._def.checks.find((e) => e.kind === "uuid");
+	}
+	get isNANOID() {
+		return !!this._def.checks.find((e) => e.kind === "nanoid");
+	}
+	get isCUID() {
+		return !!this._def.checks.find((e) => e.kind === "cuid");
+	}
+	get isCUID2() {
+		return !!this._def.checks.find((e) => e.kind === "cuid2");
+	}
+	get isULID() {
+		return !!this._def.checks.find((e) => e.kind === "ulid");
+	}
+	get isIP() {
+		return !!this._def.checks.find((e) => e.kind === "ip");
+	}
+	get isCIDR() {
+		return !!this._def.checks.find((e) => e.kind === "cidr");
+	}
+	get isBase64() {
+		return !!this._def.checks.find((e) => e.kind === "base64");
+	}
+	get isBase64url() {
+		return !!this._def.checks.find((e) => e.kind === "base64url");
+	}
+	get minLength() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+		return e;
+	}
+	get maxLength() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+		return e;
+	}
+};
+y.create = (e) => new y({
+	checks: [],
+	typeName: $.ZodString,
+	coerce: e?.coerce ?? !1,
+	..._(e)
+});
+function De(e, t) {
+	let n = (e.toString().split(".")[1] || "").length, r = (t.toString().split(".")[1] || "").length, i = n > r ? n : r;
+	return Number.parseInt(e.toFixed(i).replace(".", "")) % Number.parseInt(t.toFixed(i).replace(".", "")) / 10 ** i;
+}
+var b = class t extends v {
+	constructor() {
+		super(...arguments), this.min = this.gte, this.max = this.lte, this.step = this.multipleOf;
+	}
+	_parse(t) {
+		if (this._def.coerce && (t.data = Number(t.data)), this._getType(t) !== e.number) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.number,
+				received: n.parsedType
+			}), c;
+		}
+		let r, a = new u();
+		for (let e of this._def.checks) e.kind === "int" ? n.isInteger(t.data) || (r = this._getOrReturnCtx(t, r), d(r, {
+			code: i.invalid_type,
+			expected: "integer",
+			received: "float",
+			message: e.message
+		}), a.dirty()) : e.kind === "min" ? (e.inclusive ? t.data < e.value : t.data <= e.value) && (r = this._getOrReturnCtx(t, r), d(r, {
+			code: i.too_small,
+			minimum: e.value,
+			type: "number",
+			inclusive: e.inclusive,
+			exact: !1,
+			message: e.message
+		}), a.dirty()) : e.kind === "max" ? (e.inclusive ? t.data > e.value : t.data >= e.value) && (r = this._getOrReturnCtx(t, r), d(r, {
+			code: i.too_big,
+			maximum: e.value,
+			type: "number",
+			inclusive: e.inclusive,
+			exact: !1,
+			message: e.message
+		}), a.dirty()) : e.kind === "multipleOf" ? De(t.data, e.value) !== 0 && (r = this._getOrReturnCtx(t, r), d(r, {
+			code: i.not_multiple_of,
+			multipleOf: e.value,
+			message: e.message
+		}), a.dirty()) : e.kind === "finite" ? Number.isFinite(t.data) || (r = this._getOrReturnCtx(t, r), d(r, {
+			code: i.not_finite,
+			message: e.message
+		}), a.dirty()) : n.assertNever(e);
+		return {
+			status: a.value,
+			value: t.data
+		};
+	}
+	gte(e, t) {
+		return this.setLimit("min", e, !0, h.toString(t));
+	}
+	gt(e, t) {
+		return this.setLimit("min", e, !1, h.toString(t));
+	}
+	lte(e, t) {
+		return this.setLimit("max", e, !0, h.toString(t));
+	}
+	lt(e, t) {
+		return this.setLimit("max", e, !1, h.toString(t));
+	}
+	setLimit(e, n, r, i) {
+		return new t({
+			...this._def,
+			checks: [...this._def.checks, {
+				kind: e,
+				value: n,
+				inclusive: r,
+				message: h.toString(i)
+			}]
+		});
+	}
+	_addCheck(e) {
+		return new t({
+			...this._def,
+			checks: [...this._def.checks, e]
+		});
+	}
+	int(e) {
+		return this._addCheck({
+			kind: "int",
+			message: h.toString(e)
+		});
+	}
+	positive(e) {
+		return this._addCheck({
+			kind: "min",
+			value: 0,
+			inclusive: !1,
+			message: h.toString(e)
+		});
+	}
+	negative(e) {
+		return this._addCheck({
+			kind: "max",
+			value: 0,
+			inclusive: !1,
+			message: h.toString(e)
+		});
+	}
+	nonpositive(e) {
+		return this._addCheck({
+			kind: "max",
+			value: 0,
+			inclusive: !0,
+			message: h.toString(e)
+		});
+	}
+	nonnegative(e) {
+		return this._addCheck({
+			kind: "min",
+			value: 0,
+			inclusive: !0,
+			message: h.toString(e)
+		});
+	}
+	multipleOf(e, t) {
+		return this._addCheck({
+			kind: "multipleOf",
+			value: e,
+			message: h.toString(t)
+		});
+	}
+	finite(e) {
+		return this._addCheck({
+			kind: "finite",
+			message: h.toString(e)
+		});
+	}
+	safe(e) {
+		return this._addCheck({
+			kind: "min",
+			inclusive: !0,
+			value: -(2 ** 53 - 1),
+			message: h.toString(e)
+		})._addCheck({
+			kind: "max",
+			inclusive: !0,
+			value: 2 ** 53 - 1,
+			message: h.toString(e)
+		});
+	}
+	get minValue() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+		return e;
+	}
+	get maxValue() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+		return e;
+	}
+	get isInt() {
+		return !!this._def.checks.find((e) => e.kind === "int" || e.kind === "multipleOf" && n.isInteger(e.value));
+	}
+	get isFinite() {
+		let e = null, t = null;
+		for (let n of this._def.checks) if (n.kind === "finite" || n.kind === "int" || n.kind === "multipleOf") return !0;
+		else n.kind === "min" ? (t === null || n.value > t) && (t = n.value) : n.kind === "max" && (e === null || n.value < e) && (e = n.value);
+		return Number.isFinite(t) && Number.isFinite(e);
+	}
+};
+b.create = (e) => new b({
+	checks: [],
+	typeName: $.ZodNumber,
+	coerce: e?.coerce || !1,
+	..._(e)
+});
+var x = class t extends v {
+	constructor() {
+		super(...arguments), this.min = this.gte, this.max = this.lte;
+	}
+	_parse(t) {
+		if (this._def.coerce) try {
+			t.data = BigInt(t.data);
+		} catch {
+			return this._getInvalidInput(t);
+		}
+		if (this._getType(t) !== e.bigint) return this._getInvalidInput(t);
+		let r, a = new u();
+		for (let e of this._def.checks) e.kind === "min" ? (e.inclusive ? t.data < e.value : t.data <= e.value) && (r = this._getOrReturnCtx(t, r), d(r, {
+			code: i.too_small,
+			type: "bigint",
+			minimum: e.value,
+			inclusive: e.inclusive,
+			message: e.message
+		}), a.dirty()) : e.kind === "max" ? (e.inclusive ? t.data > e.value : t.data >= e.value) && (r = this._getOrReturnCtx(t, r), d(r, {
+			code: i.too_big,
+			type: "bigint",
+			maximum: e.value,
+			inclusive: e.inclusive,
+			message: e.message
+		}), a.dirty()) : e.kind === "multipleOf" ? t.data % e.value !== BigInt(0) && (r = this._getOrReturnCtx(t, r), d(r, {
+			code: i.not_multiple_of,
+			multipleOf: e.value,
+			message: e.message
+		}), a.dirty()) : n.assertNever(e);
+		return {
+			status: a.value,
+			value: t.data
+		};
+	}
+	_getInvalidInput(t) {
+		let n = this._getOrReturnCtx(t);
+		return d(n, {
+			code: i.invalid_type,
+			expected: e.bigint,
+			received: n.parsedType
+		}), c;
+	}
+	gte(e, t) {
+		return this.setLimit("min", e, !0, h.toString(t));
+	}
+	gt(e, t) {
+		return this.setLimit("min", e, !1, h.toString(t));
+	}
+	lte(e, t) {
+		return this.setLimit("max", e, !0, h.toString(t));
+	}
+	lt(e, t) {
+		return this.setLimit("max", e, !1, h.toString(t));
+	}
+	setLimit(e, n, r, i) {
+		return new t({
+			...this._def,
+			checks: [...this._def.checks, {
+				kind: e,
+				value: n,
+				inclusive: r,
+				message: h.toString(i)
+			}]
+		});
+	}
+	_addCheck(e) {
+		return new t({
+			...this._def,
+			checks: [...this._def.checks, e]
+		});
+	}
+	positive(e) {
+		return this._addCheck({
+			kind: "min",
+			value: BigInt(0),
+			inclusive: !1,
+			message: h.toString(e)
+		});
+	}
+	negative(e) {
+		return this._addCheck({
+			kind: "max",
+			value: BigInt(0),
+			inclusive: !1,
+			message: h.toString(e)
+		});
+	}
+	nonpositive(e) {
+		return this._addCheck({
+			kind: "max",
+			value: BigInt(0),
+			inclusive: !0,
+			message: h.toString(e)
+		});
+	}
+	nonnegative(e) {
+		return this._addCheck({
+			kind: "min",
+			value: BigInt(0),
+			inclusive: !0,
+			message: h.toString(e)
+		});
+	}
+	multipleOf(e, t) {
+		return this._addCheck({
+			kind: "multipleOf",
+			value: e,
+			message: h.toString(t)
+		});
+	}
+	get minValue() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+		return e;
+	}
+	get maxValue() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+		return e;
+	}
+};
+x.create = (e) => new x({
+	checks: [],
+	typeName: $.ZodBigInt,
+	coerce: e?.coerce ?? !1,
+	..._(e)
+});
+var S = class extends v {
+	_parse(t) {
+		if (this._def.coerce && (t.data = !!t.data), this._getType(t) !== e.boolean) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.boolean,
+				received: n.parsedType
+			}), c;
+		}
+		return l(t.data);
+	}
+};
+S.create = (e) => new S({
+	typeName: $.ZodBoolean,
+	coerce: e?.coerce || !1,
+	..._(e)
+});
+var C = class t extends v {
+	_parse(t) {
+		if (this._def.coerce && (t.data = new Date(t.data)), this._getType(t) !== e.date) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.date,
+				received: n.parsedType
+			}), c;
+		}
+		if (Number.isNaN(t.data.getTime())) return d(this._getOrReturnCtx(t), { code: i.invalid_date }), c;
+		let r = new u(), a;
+		for (let e of this._def.checks) e.kind === "min" ? t.data.getTime() < e.value && (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.too_small,
+			message: e.message,
+			inclusive: !0,
+			exact: !1,
+			minimum: e.value,
+			type: "date"
+		}), r.dirty()) : e.kind === "max" ? t.data.getTime() > e.value && (a = this._getOrReturnCtx(t, a), d(a, {
+			code: i.too_big,
+			message: e.message,
+			inclusive: !0,
+			exact: !1,
+			maximum: e.value,
+			type: "date"
+		}), r.dirty()) : n.assertNever(e);
+		return {
+			status: r.value,
+			value: new Date(t.data.getTime())
+		};
+	}
+	_addCheck(e) {
+		return new t({
+			...this._def,
+			checks: [...this._def.checks, e]
+		});
+	}
+	min(e, t) {
+		return this._addCheck({
+			kind: "min",
+			value: e.getTime(),
+			message: h.toString(t)
+		});
+	}
+	max(e, t) {
+		return this._addCheck({
+			kind: "max",
+			value: e.getTime(),
+			message: h.toString(t)
+		});
+	}
+	get minDate() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "min" && (e === null || t.value > e) && (e = t.value);
+		return e == null ? null : new Date(e);
+	}
+	get maxDate() {
+		let e = null;
+		for (let t of this._def.checks) t.kind === "max" && (e === null || t.value < e) && (e = t.value);
+		return e == null ? null : new Date(e);
+	}
+};
+C.create = (e) => new C({
+	checks: [],
+	coerce: e?.coerce || !1,
+	typeName: $.ZodDate,
+	..._(e)
+});
+var w = class extends v {
+	_parse(t) {
+		if (this._getType(t) !== e.symbol) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.symbol,
+				received: n.parsedType
+			}), c;
+		}
+		return l(t.data);
+	}
+};
+w.create = (e) => new w({
+	typeName: $.ZodSymbol,
+	..._(e)
+});
+var T = class extends v {
+	_parse(t) {
+		if (this._getType(t) !== e.undefined) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.undefined,
+				received: n.parsedType
+			}), c;
+		}
+		return l(t.data);
+	}
+};
+T.create = (e) => new T({
+	typeName: $.ZodUndefined,
+	..._(e)
+});
+var E = class extends v {
+	_parse(t) {
+		if (this._getType(t) !== e.null) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.null,
+				received: n.parsedType
+			}), c;
+		}
+		return l(t.data);
+	}
+};
+E.create = (e) => new E({
+	typeName: $.ZodNull,
+	..._(e)
+});
+var D = class extends v {
+	constructor() {
+		super(...arguments), this._any = !0;
+	}
+	_parse(e) {
+		return l(e.data);
+	}
+};
+D.create = (e) => new D({
+	typeName: $.ZodAny,
+	..._(e)
+});
+var O = class extends v {
+	constructor() {
+		super(...arguments), this._unknown = !0;
+	}
+	_parse(e) {
+		return l(e.data);
+	}
+};
+O.create = (e) => new O({
+	typeName: $.ZodUnknown,
+	..._(e)
+});
+var k = class extends v {
+	_parse(t) {
+		let n = this._getOrReturnCtx(t);
+		return d(n, {
+			code: i.invalid_type,
+			expected: e.never,
+			received: n.parsedType
+		}), c;
+	}
+};
+k.create = (e) => new k({
+	typeName: $.ZodNever,
+	..._(e)
+});
+var A = class extends v {
+	_parse(t) {
+		if (this._getType(t) !== e.undefined) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.void,
+				received: n.parsedType
+			}), c;
+		}
+		return l(t.data);
+	}
+};
+A.create = (e) => new A({
+	typeName: $.ZodVoid,
+	..._(e)
+});
+var j = class t extends v {
+	_parse(t) {
+		let { ctx: n, status: r } = this._processInputParams(t), a = this._def;
+		if (n.parsedType !== e.array) return d(n, {
+			code: i.invalid_type,
+			expected: e.array,
+			received: n.parsedType
+		}), c;
+		if (a.exactLength !== null) {
+			let e = n.data.length > a.exactLength.value, t = n.data.length < a.exactLength.value;
+			(e || t) && (d(n, {
+				code: e ? i.too_big : i.too_small,
+				minimum: t ? a.exactLength.value : void 0,
+				maximum: e ? a.exactLength.value : void 0,
+				type: "array",
+				inclusive: !0,
+				exact: !0,
+				message: a.exactLength.message
+			}), r.dirty());
+		}
+		if (a.minLength !== null && n.data.length < a.minLength.value && (d(n, {
+			code: i.too_small,
+			minimum: a.minLength.value,
+			type: "array",
+			inclusive: !0,
+			exact: !1,
+			message: a.minLength.message
+		}), r.dirty()), a.maxLength !== null && n.data.length > a.maxLength.value && (d(n, {
+			code: i.too_big,
+			maximum: a.maxLength.value,
+			type: "array",
+			inclusive: !0,
+			exact: !1,
+			message: a.maxLength.message
+		}), r.dirty()), n.common.async) return Promise.all([...n.data].map((e, t) => a.type._parseAsync(new g(n, e, n.path, t)))).then((e) => u.mergeArray(r, e));
+		let o = [...n.data].map((e, t) => a.type._parseSync(new g(n, e, n.path, t)));
+		return u.mergeArray(r, o);
+	}
+	get element() {
+		return this._def.type;
+	}
+	min(e, n) {
+		return new t({
+			...this._def,
+			minLength: {
+				value: e,
+				message: h.toString(n)
+			}
+		});
+	}
+	max(e, n) {
+		return new t({
+			...this._def,
+			maxLength: {
+				value: e,
+				message: h.toString(n)
+			}
+		});
+	}
+	length(e, n) {
+		return new t({
+			...this._def,
+			exactLength: {
+				value: e,
+				message: h.toString(n)
+			}
+		});
+	}
+	nonempty(e) {
+		return this.min(1, e);
+	}
+};
+j.create = (e, t) => new j({
+	type: e,
+	minLength: null,
+	maxLength: null,
+	exactLength: null,
+	typeName: $.ZodArray,
+	..._(t)
+});
+function M(e) {
+	if (e instanceof N) {
+		let t = {};
+		for (let n in e.shape) {
+			let r = e.shape[n];
+			t[n] = q.create(M(r));
+		}
+		return new N({
+			...e._def,
+			shape: () => t
+		});
+	} else if (e instanceof j) return new j({
+		...e._def,
+		type: M(e.element)
+	});
+	else if (e instanceof q) return q.create(M(e.unwrap()));
+	else if (e instanceof J) return J.create(M(e.unwrap()));
+	else if (e instanceof R) return R.create(e.items.map((e) => M(e)));
+	else return e;
+}
+var N = class t extends v {
+	constructor() {
+		super(...arguments), this._cached = null, this.nonstrict = this.passthrough, this.augment = this.extend;
+	}
+	_getCached() {
+		if (this._cached !== null) return this._cached;
+		let e = this._def.shape();
+		return this._cached = {
+			shape: e,
+			keys: n.objectKeys(e)
+		}, this._cached;
+	}
+	_parse(t) {
+		if (this._getType(t) !== e.object) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.object,
+				received: n.parsedType
+			}), c;
+		}
+		let { status: n, ctx: r } = this._processInputParams(t), { shape: a, keys: o } = this._getCached(), s = [];
+		if (!(this._def.catchall instanceof k && this._def.unknownKeys === "strip")) for (let e in r.data) o.includes(e) || s.push(e);
+		let l = [];
+		for (let e of o) {
+			let t = a[e], n = r.data[e];
+			l.push({
+				key: {
+					status: "valid",
+					value: e
+				},
+				value: t._parse(new g(r, n, r.path, e)),
+				alwaysSet: e in r.data
+			});
+		}
+		if (this._def.catchall instanceof k) {
+			let e = this._def.unknownKeys;
+			if (e === "passthrough") for (let e of s) l.push({
+				key: {
+					status: "valid",
+					value: e
+				},
+				value: {
+					status: "valid",
+					value: r.data[e]
+				}
+			});
+			else if (e === "strict") s.length > 0 && (d(r, {
+				code: i.unrecognized_keys,
+				keys: s
+			}), n.dirty());
+			else if (e !== "strip") throw Error("Internal ZodObject error: invalid unknownKeys value.");
+		} else {
+			let e = this._def.catchall;
+			for (let t of s) {
+				let n = r.data[t];
+				l.push({
+					key: {
+						status: "valid",
+						value: t
+					},
+					value: e._parse(new g(r, n, r.path, t)),
+					alwaysSet: t in r.data
+				});
+			}
+		}
+		return r.common.async ? Promise.resolve().then(async () => {
+			let e = [];
+			for (let t of l) {
+				let n = await t.key, r = await t.value;
+				e.push({
+					key: n,
+					value: r,
+					alwaysSet: t.alwaysSet
+				});
+			}
+			return e;
+		}).then((e) => u.mergeObjectSync(n, e)) : u.mergeObjectSync(n, l);
+	}
+	get shape() {
+		return this._def.shape();
+	}
+	strict(e) {
+		return h.errToObj, new t({
+			...this._def,
+			unknownKeys: "strict",
+			...e === void 0 ? {} : { errorMap: (t, n) => {
+				let r = this._def.errorMap?.(t, n).message ?? n.defaultError;
+				return t.code === "unrecognized_keys" ? { message: h.errToObj(e).message ?? r } : { message: r };
+			} }
+		});
+	}
+	strip() {
+		return new t({
+			...this._def,
+			unknownKeys: "strip"
+		});
+	}
+	passthrough() {
+		return new t({
+			...this._def,
+			unknownKeys: "passthrough"
+		});
+	}
+	extend(e) {
+		return new t({
+			...this._def,
+			shape: () => ({
+				...this._def.shape(),
+				...e
+			})
+		});
+	}
+	merge(e) {
+		return new t({
+			unknownKeys: e._def.unknownKeys,
+			catchall: e._def.catchall,
+			shape: () => ({
+				...this._def.shape(),
+				...e._def.shape()
+			}),
+			typeName: $.ZodObject
+		});
+	}
+	setKey(e, t) {
+		return this.augment({ [e]: t });
+	}
+	catchall(e) {
+		return new t({
+			...this._def,
+			catchall: e
+		});
+	}
+	pick(e) {
+		let r = {};
+		for (let t of n.objectKeys(e)) e[t] && this.shape[t] && (r[t] = this.shape[t]);
+		return new t({
+			...this._def,
+			shape: () => r
+		});
+	}
+	omit(e) {
+		let r = {};
+		for (let t of n.objectKeys(this.shape)) e[t] || (r[t] = this.shape[t]);
+		return new t({
+			...this._def,
+			shape: () => r
+		});
+	}
+	deepPartial() {
+		return M(this);
+	}
+	partial(e) {
+		let r = {};
+		for (let t of n.objectKeys(this.shape)) {
+			let n = this.shape[t];
+			e && !e[t] ? r[t] = n : r[t] = n.optional();
+		}
+		return new t({
+			...this._def,
+			shape: () => r
+		});
+	}
+	required(e) {
+		let r = {};
+		for (let t of n.objectKeys(this.shape)) if (e && !e[t]) r[t] = this.shape[t];
+		else {
+			let e = this.shape[t];
+			for (; e instanceof q;) e = e._def.innerType;
+			r[t] = e;
+		}
+		return new t({
+			...this._def,
+			shape: () => r
+		});
+	}
+	keyof() {
+		return je(n.objectKeys(this.shape));
+	}
+};
+N.create = (e, t) => new N({
+	shape: () => e,
+	unknownKeys: "strip",
+	catchall: k.create(),
+	typeName: $.ZodObject,
+	..._(t)
+}), N.strictCreate = (e, t) => new N({
+	shape: () => e,
+	unknownKeys: "strict",
+	catchall: k.create(),
+	typeName: $.ZodObject,
+	..._(t)
+}), N.lazycreate = (e, t) => new N({
+	shape: e,
+	unknownKeys: "strip",
+	catchall: k.create(),
+	typeName: $.ZodObject,
+	..._(t)
+});
+var P = class extends v {
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e), n = this._def.options;
+		function a(e) {
+			for (let t of e) if (t.result.status === "valid") return t.result;
+			for (let n of e) if (n.result.status === "dirty") return t.common.issues.push(...n.ctx.common.issues), n.result;
+			let n = e.map((e) => new r(e.ctx.common.issues));
+			return d(t, {
+				code: i.invalid_union,
+				unionErrors: n
+			}), c;
+		}
+		if (t.common.async) return Promise.all(n.map(async (e) => {
+			let n = {
+				...t,
+				common: {
+					...t.common,
+					issues: []
+				},
+				parent: null
+			};
+			return {
+				result: await e._parseAsync({
+					data: t.data,
+					path: t.path,
+					parent: n
+				}),
+				ctx: n
+			};
+		})).then(a);
+		{
+			let e, a = [];
+			for (let r of n) {
+				let n = {
+					...t,
+					common: {
+						...t.common,
+						issues: []
+					},
+					parent: null
+				}, i = r._parseSync({
+					data: t.data,
+					path: t.path,
+					parent: n
+				});
+				if (i.status === "valid") return i;
+				i.status === "dirty" && !e && (e = {
+					result: i,
+					ctx: n
+				}), n.common.issues.length && a.push(n.common.issues);
+			}
+			if (e) return t.common.issues.push(...e.ctx.common.issues), e.result;
+			let o = a.map((e) => new r(e));
+			return d(t, {
+				code: i.invalid_union,
+				unionErrors: o
+			}), c;
+		}
+	}
+	get options() {
+		return this._def.options;
+	}
+};
+P.create = (e, t) => new P({
+	options: e,
+	typeName: $.ZodUnion,
+	..._(t)
+});
+var F = (e) => e instanceof V ? F(e.schema) : e instanceof K ? F(e.innerType()) : e instanceof H ? [e.value] : e instanceof U ? e.options : e instanceof W ? n.objectValues(e.enum) : e instanceof Y ? F(e._def.innerType) : e instanceof T ? [void 0] : e instanceof E ? [null] : e instanceof q ? [void 0, ...F(e.unwrap())] : e instanceof J ? [null, ...F(e.unwrap())] : e instanceof Me || e instanceof Q ? F(e.unwrap()) : e instanceof X ? F(e._def.innerType) : [], Oe = class t extends v {
+	_parse(t) {
+		let { ctx: n } = this._processInputParams(t);
+		if (n.parsedType !== e.object) return d(n, {
+			code: i.invalid_type,
+			expected: e.object,
+			received: n.parsedType
+		}), c;
+		let r = this.discriminator, a = n.data[r], o = this.optionsMap.get(a);
+		return o ? n.common.async ? o._parseAsync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		}) : o._parseSync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		}) : (d(n, {
+			code: i.invalid_union_discriminator,
+			options: Array.from(this.optionsMap.keys()),
+			path: [r]
+		}), c);
+	}
+	get discriminator() {
+		return this._def.discriminator;
+	}
+	get options() {
+		return this._def.options;
+	}
+	get optionsMap() {
+		return this._def.optionsMap;
+	}
+	static create(e, n, r) {
+		let i = /* @__PURE__ */ new Map();
+		for (let t of n) {
+			let n = F(t.shape[e]);
+			if (!n.length) throw Error(`A discriminator value for key \`${e}\` could not be extracted from all schema options`);
+			for (let r of n) {
+				if (i.has(r)) throw Error(`Discriminator property ${String(e)} has duplicate value ${String(r)}`);
+				i.set(r, t);
+			}
+		}
+		return new t({
+			typeName: $.ZodDiscriminatedUnion,
+			discriminator: e,
+			options: n,
+			optionsMap: i,
+			..._(r)
+		});
+	}
+};
+function I(r, i) {
+	let a = t(r), o = t(i);
+	if (r === i) return {
+		valid: !0,
+		data: r
+	};
+	if (a === e.object && o === e.object) {
+		let e = n.objectKeys(i), t = n.objectKeys(r).filter((t) => e.indexOf(t) !== -1), a = {
+			...r,
+			...i
+		};
+		for (let e of t) {
+			let t = I(r[e], i[e]);
+			if (!t.valid) return { valid: !1 };
+			a[e] = t.data;
+		}
+		return {
+			valid: !0,
+			data: a
+		};
+	} else if (a === e.array && o === e.array) {
+		if (r.length !== i.length) return { valid: !1 };
+		let e = [];
+		for (let t = 0; t < r.length; t++) {
+			let n = r[t], a = i[t], o = I(n, a);
+			if (!o.valid) return { valid: !1 };
+			e.push(o.data);
+		}
+		return {
+			valid: !0,
+			data: e
+		};
+	} else if (a === e.date && o === e.date && +r == +i) return {
+		valid: !0,
+		data: r
+	};
+	else return { valid: !1 };
+}
+var L = class extends v {
+	_parse(e) {
+		let { status: t, ctx: n } = this._processInputParams(e), r = (e, r) => {
+			if (f(e) || f(r)) return c;
+			let a = I(e.value, r.value);
+			return a.valid ? ((ee(e) || ee(r)) && t.dirty(), {
+				status: t.value,
+				value: a.data
+			}) : (d(n, { code: i.invalid_intersection_types }), c);
+		};
+		return n.common.async ? Promise.all([this._def.left._parseAsync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		}), this._def.right._parseAsync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		})]).then(([e, t]) => r(e, t)) : r(this._def.left._parseSync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		}), this._def.right._parseSync({
+			data: n.data,
+			path: n.path,
+			parent: n
+		}));
+	}
+};
+L.create = (e, t, n) => new L({
+	left: e,
+	right: t,
+	typeName: $.ZodIntersection,
+	..._(n)
+});
+var R = class t extends v {
+	_parse(t) {
+		let { status: n, ctx: r } = this._processInputParams(t);
+		if (r.parsedType !== e.array) return d(r, {
+			code: i.invalid_type,
+			expected: e.array,
+			received: r.parsedType
+		}), c;
+		if (r.data.length < this._def.items.length) return d(r, {
+			code: i.too_small,
+			minimum: this._def.items.length,
+			inclusive: !0,
+			exact: !1,
+			type: "array"
+		}), c;
+		!this._def.rest && r.data.length > this._def.items.length && (d(r, {
+			code: i.too_big,
+			maximum: this._def.items.length,
+			inclusive: !0,
+			exact: !1,
+			type: "array"
+		}), n.dirty());
+		let a = [...r.data].map((e, t) => {
+			let n = this._def.items[t] || this._def.rest;
+			return n ? n._parse(new g(r, e, r.path, t)) : null;
+		}).filter((e) => !!e);
+		return r.common.async ? Promise.all(a).then((e) => u.mergeArray(n, e)) : u.mergeArray(n, a);
+	}
+	get items() {
+		return this._def.items;
+	}
+	rest(e) {
+		return new t({
+			...this._def,
+			rest: e
+		});
+	}
+};
+R.create = (e, t) => {
+	if (!Array.isArray(e)) throw Error("You must pass an array of schemas to z.tuple([ ... ])");
+	return new R({
+		items: e,
+		typeName: $.ZodTuple,
+		rest: null,
+		..._(t)
+	});
+};
+var ke = class t extends v {
+	get keySchema() {
+		return this._def.keyType;
+	}
+	get valueSchema() {
+		return this._def.valueType;
+	}
+	_parse(t) {
+		let { status: n, ctx: r } = this._processInputParams(t);
+		if (r.parsedType !== e.object) return d(r, {
+			code: i.invalid_type,
+			expected: e.object,
+			received: r.parsedType
+		}), c;
+		let a = [], o = this._def.keyType, s = this._def.valueType;
+		for (let e in r.data) a.push({
+			key: o._parse(new g(r, e, r.path, e)),
+			value: s._parse(new g(r, r.data[e], r.path, e)),
+			alwaysSet: e in r.data
+		});
+		return r.common.async ? u.mergeObjectAsync(n, a) : u.mergeObjectSync(n, a);
+	}
+	get element() {
+		return this._def.valueType;
+	}
+	static create(e, n, r) {
+		return n instanceof v ? new t({
+			keyType: e,
+			valueType: n,
+			typeName: $.ZodRecord,
+			..._(r)
+		}) : new t({
+			keyType: y.create(),
+			valueType: e,
+			typeName: $.ZodRecord,
+			..._(n)
+		});
+	}
+}, z = class extends v {
+	get keySchema() {
+		return this._def.keyType;
+	}
+	get valueSchema() {
+		return this._def.valueType;
+	}
+	_parse(t) {
+		let { status: n, ctx: r } = this._processInputParams(t);
+		if (r.parsedType !== e.map) return d(r, {
+			code: i.invalid_type,
+			expected: e.map,
+			received: r.parsedType
+		}), c;
+		let a = this._def.keyType, o = this._def.valueType, s = [...r.data.entries()].map(([e, t], n) => ({
+			key: a._parse(new g(r, e, r.path, [n, "key"])),
+			value: o._parse(new g(r, t, r.path, [n, "value"]))
+		}));
+		if (r.common.async) {
+			let e = /* @__PURE__ */ new Map();
+			return Promise.resolve().then(async () => {
+				for (let t of s) {
+					let r = await t.key, i = await t.value;
+					if (r.status === "aborted" || i.status === "aborted") return c;
+					(r.status === "dirty" || i.status === "dirty") && n.dirty(), e.set(r.value, i.value);
+				}
+				return {
+					status: n.value,
+					value: e
+				};
+			});
+		} else {
+			let e = /* @__PURE__ */ new Map();
+			for (let t of s) {
+				let r = t.key, i = t.value;
+				if (r.status === "aborted" || i.status === "aborted") return c;
+				(r.status === "dirty" || i.status === "dirty") && n.dirty(), e.set(r.value, i.value);
+			}
+			return {
+				status: n.value,
+				value: e
+			};
+		}
+	}
+};
+z.create = (e, t, n) => new z({
+	valueType: t,
+	keyType: e,
+	typeName: $.ZodMap,
+	..._(n)
+});
+var B = class t extends v {
+	_parse(t) {
+		let { status: n, ctx: r } = this._processInputParams(t);
+		if (r.parsedType !== e.set) return d(r, {
+			code: i.invalid_type,
+			expected: e.set,
+			received: r.parsedType
+		}), c;
+		let a = this._def;
+		a.minSize !== null && r.data.size < a.minSize.value && (d(r, {
+			code: i.too_small,
+			minimum: a.minSize.value,
+			type: "set",
+			inclusive: !0,
+			exact: !1,
+			message: a.minSize.message
+		}), n.dirty()), a.maxSize !== null && r.data.size > a.maxSize.value && (d(r, {
+			code: i.too_big,
+			maximum: a.maxSize.value,
+			type: "set",
+			inclusive: !0,
+			exact: !1,
+			message: a.maxSize.message
+		}), n.dirty());
+		let o = this._def.valueType;
+		function s(e) {
+			let t = /* @__PURE__ */ new Set();
+			for (let r of e) {
+				if (r.status === "aborted") return c;
+				r.status === "dirty" && n.dirty(), t.add(r.value);
+			}
+			return {
+				status: n.value,
+				value: t
+			};
+		}
+		let l = [...r.data.values()].map((e, t) => o._parse(new g(r, e, r.path, t)));
+		return r.common.async ? Promise.all(l).then((e) => s(e)) : s(l);
+	}
+	min(e, n) {
+		return new t({
+			...this._def,
+			minSize: {
+				value: e,
+				message: h.toString(n)
+			}
+		});
+	}
+	max(e, n) {
+		return new t({
+			...this._def,
+			maxSize: {
+				value: e,
+				message: h.toString(n)
+			}
+		});
+	}
+	size(e, t) {
+		return this.min(e, t).max(e, t);
+	}
+	nonempty(e) {
+		return this.min(1, e);
+	}
+};
+B.create = (e, t) => new B({
+	valueType: e,
+	minSize: null,
+	maxSize: null,
+	typeName: $.ZodSet,
+	..._(t)
+});
+var Ae = class t extends v {
+	constructor() {
+		super(...arguments), this.validate = this.implement;
+	}
+	_parse(t) {
+		let { ctx: n } = this._processInputParams(t);
+		if (n.parsedType !== e.function) return d(n, {
+			code: i.invalid_type,
+			expected: e.function,
+			received: n.parsedType
+		}), c;
+		function s(e, t) {
+			return te({
+				data: e,
+				path: n.path,
+				errorMaps: [
+					n.common.contextualErrorMap,
+					n.schemaErrorMap,
+					o(),
+					a
+				].filter((e) => !!e),
+				issueData: {
+					code: i.invalid_arguments,
+					argumentsError: t
+				}
+			});
+		}
+		function u(e, t) {
+			return te({
+				data: e,
+				path: n.path,
+				errorMaps: [
+					n.common.contextualErrorMap,
+					n.schemaErrorMap,
+					o(),
+					a
+				].filter((e) => !!e),
+				issueData: {
+					code: i.invalid_return_type,
+					returnTypeError: t
+				}
+			});
+		}
+		let f = { errorMap: n.common.contextualErrorMap }, p = n.data;
+		if (this._def.returns instanceof G) {
+			let e = this;
+			return l(async function(...t) {
+				let n = new r([]), i = await e._def.args.parseAsync(t, f).catch((e) => {
+					throw n.addIssue(s(t, e)), n;
+				}), a = await Reflect.apply(p, this, i);
+				return await e._def.returns._def.type.parseAsync(a, f).catch((e) => {
+					throw n.addIssue(u(a, e)), n;
+				});
+			});
+		} else {
+			let e = this;
+			return l(function(...t) {
+				let n = e._def.args.safeParse(t, f);
+				if (!n.success) throw new r([s(t, n.error)]);
+				let i = Reflect.apply(p, this, n.data), a = e._def.returns.safeParse(i, f);
+				if (!a.success) throw new r([u(i, a.error)]);
+				return a.data;
+			});
+		}
+	}
+	parameters() {
+		return this._def.args;
+	}
+	returnType() {
+		return this._def.returns;
+	}
+	args(...e) {
+		return new t({
+			...this._def,
+			args: R.create(e).rest(O.create())
+		});
+	}
+	returns(e) {
+		return new t({
+			...this._def,
+			returns: e
+		});
+	}
+	implement(e) {
+		return this.parse(e);
+	}
+	strictImplement(e) {
+		return this.parse(e);
+	}
+	static create(e, n, r) {
+		return new t({
+			args: e || R.create([]).rest(O.create()),
+			returns: n || O.create(),
+			typeName: $.ZodFunction,
+			..._(r)
+		});
+	}
+}, V = class extends v {
+	get schema() {
+		return this._def.getter();
+	}
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e);
+		return this._def.getter()._parse({
+			data: t.data,
+			path: t.path,
+			parent: t
+		});
+	}
+};
+V.create = (e, t) => new V({
+	getter: e,
+	typeName: $.ZodLazy,
+	..._(t)
+});
+var H = class extends v {
+	_parse(e) {
+		if (e.data !== this._def.value) {
+			let t = this._getOrReturnCtx(e);
+			return d(t, {
+				received: t.data,
+				code: i.invalid_literal,
+				expected: this._def.value
+			}), c;
+		}
+		return {
+			status: "valid",
+			value: e.data
+		};
+	}
+	get value() {
+		return this._def.value;
+	}
+};
+H.create = (e, t) => new H({
+	value: e,
+	typeName: $.ZodLiteral,
+	..._(t)
+});
+function je(e, t) {
+	return new U({
+		values: e,
+		typeName: $.ZodEnum,
+		..._(t)
+	});
+}
+var U = class e extends v {
+	_parse(e) {
+		if (typeof e.data != "string") {
+			let t = this._getOrReturnCtx(e), r = this._def.values;
+			return d(t, {
+				expected: n.joinValues(r),
+				received: t.parsedType,
+				code: i.invalid_type
+			}), c;
+		}
+		if (this._cache ||= new Set(this._def.values), !this._cache.has(e.data)) {
+			let t = this._getOrReturnCtx(e), n = this._def.values;
+			return d(t, {
+				received: t.data,
+				code: i.invalid_enum_value,
+				options: n
+			}), c;
+		}
+		return l(e.data);
+	}
+	get options() {
+		return this._def.values;
+	}
+	get enum() {
+		let e = {};
+		for (let t of this._def.values) e[t] = t;
+		return e;
+	}
+	get Values() {
+		let e = {};
+		for (let t of this._def.values) e[t] = t;
+		return e;
+	}
+	get Enum() {
+		let e = {};
+		for (let t of this._def.values) e[t] = t;
+		return e;
+	}
+	extract(t, n = this._def) {
+		return e.create(t, {
+			...this._def,
+			...n
+		});
+	}
+	exclude(t, n = this._def) {
+		return e.create(this.options.filter((e) => !t.includes(e)), {
+			...this._def,
+			...n
+		});
+	}
+};
+U.create = je;
+var W = class extends v {
+	_parse(t) {
+		let r = n.getValidEnumValues(this._def.values), a = this._getOrReturnCtx(t);
+		if (a.parsedType !== e.string && a.parsedType !== e.number) {
+			let e = n.objectValues(r);
+			return d(a, {
+				expected: n.joinValues(e),
+				received: a.parsedType,
+				code: i.invalid_type
+			}), c;
+		}
+		if (this._cache ||= new Set(n.getValidEnumValues(this._def.values)), !this._cache.has(t.data)) {
+			let e = n.objectValues(r);
+			return d(a, {
+				received: a.data,
+				code: i.invalid_enum_value,
+				options: e
+			}), c;
+		}
+		return l(t.data);
+	}
+	get enum() {
+		return this._def.values;
+	}
+};
+W.create = (e, t) => new W({
+	values: e,
+	typeName: $.ZodNativeEnum,
+	..._(t)
+});
+var G = class extends v {
+	unwrap() {
+		return this._def.type;
+	}
+	_parse(t) {
+		let { ctx: n } = this._processInputParams(t);
+		return n.parsedType !== e.promise && n.common.async === !1 ? (d(n, {
+			code: i.invalid_type,
+			expected: e.promise,
+			received: n.parsedType
+		}), c) : l((n.parsedType === e.promise ? n.data : Promise.resolve(n.data)).then((e) => this._def.type.parseAsync(e, {
+			path: n.path,
+			errorMap: n.common.contextualErrorMap
+		})));
+	}
+};
+G.create = (e, t) => new G({
+	type: e,
+	typeName: $.ZodPromise,
+	..._(t)
+});
+var K = class extends v {
+	innerType() {
+		return this._def.schema;
+	}
+	sourceType() {
+		return this._def.schema._def.typeName === $.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+	}
+	_parse(e) {
+		let { status: t, ctx: r } = this._processInputParams(e), i = this._def.effect || null, a = {
+			addIssue: (e) => {
+				d(r, e), e.fatal ? t.abort() : t.dirty();
+			},
+			get path() {
+				return r.path;
+			}
+		};
+		if (a.addIssue = a.addIssue.bind(a), i.type === "preprocess") {
+			let e = i.transform(r.data, a);
+			if (r.common.async) return Promise.resolve(e).then(async (e) => {
+				if (t.value === "aborted") return c;
+				let n = await this._def.schema._parseAsync({
+					data: e,
+					path: r.path,
+					parent: r
+				});
+				return n.status === "aborted" ? c : n.status === "dirty" || t.value === "dirty" ? s(n.value) : n;
+			});
+			{
+				if (t.value === "aborted") return c;
+				let n = this._def.schema._parseSync({
+					data: e,
+					path: r.path,
+					parent: r
+				});
+				return n.status === "aborted" ? c : n.status === "dirty" || t.value === "dirty" ? s(n.value) : n;
+			}
+		}
+		if (i.type === "refinement") {
+			let e = (e) => {
+				let t = i.refinement(e, a);
+				if (r.common.async) return Promise.resolve(t);
+				if (t instanceof Promise) throw Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
+				return e;
+			};
+			if (r.common.async === !1) {
+				let n = this._def.schema._parseSync({
+					data: r.data,
+					path: r.path,
+					parent: r
+				});
+				return n.status === "aborted" ? c : (n.status === "dirty" && t.dirty(), e(n.value), {
+					status: t.value,
+					value: n.value
+				});
+			} else return this._def.schema._parseAsync({
+				data: r.data,
+				path: r.path,
+				parent: r
+			}).then((n) => n.status === "aborted" ? c : (n.status === "dirty" && t.dirty(), e(n.value).then(() => ({
+				status: t.value,
+				value: n.value
+			}))));
+		}
+		if (i.type === "transform") if (r.common.async === !1) {
+			let e = this._def.schema._parseSync({
+				data: r.data,
+				path: r.path,
+				parent: r
+			});
+			if (!m(e)) return c;
+			let n = i.transform(e.value, a);
+			if (n instanceof Promise) throw Error("Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.");
+			return {
+				status: t.value,
+				value: n
+			};
+		} else return this._def.schema._parseAsync({
+			data: r.data,
+			path: r.path,
+			parent: r
+		}).then((e) => m(e) ? Promise.resolve(i.transform(e.value, a)).then((e) => ({
+			status: t.value,
+			value: e
+		})) : c);
+		n.assertNever(i);
+	}
+};
+K.create = (e, t, n) => new K({
+	schema: e,
+	typeName: $.ZodEffects,
+	effect: t,
+	..._(n)
+}), K.createWithPreprocess = (e, t, n) => new K({
+	schema: t,
+	effect: {
+		type: "preprocess",
+		transform: e
+	},
+	typeName: $.ZodEffects,
+	..._(n)
+});
+var q = class extends v {
+	_parse(t) {
+		return this._getType(t) === e.undefined ? l(void 0) : this._def.innerType._parse(t);
+	}
+	unwrap() {
+		return this._def.innerType;
+	}
+};
+q.create = (e, t) => new q({
+	innerType: e,
+	typeName: $.ZodOptional,
+	..._(t)
+});
+var J = class extends v {
+	_parse(t) {
+		return this._getType(t) === e.null ? l(null) : this._def.innerType._parse(t);
+	}
+	unwrap() {
+		return this._def.innerType;
+	}
+};
+J.create = (e, t) => new J({
+	innerType: e,
+	typeName: $.ZodNullable,
+	..._(t)
+});
+var Y = class extends v {
+	_parse(t) {
+		let { ctx: n } = this._processInputParams(t), r = n.data;
+		return n.parsedType === e.undefined && (r = this._def.defaultValue()), this._def.innerType._parse({
+			data: r,
+			path: n.path,
+			parent: n
+		});
+	}
+	removeDefault() {
+		return this._def.innerType;
+	}
+};
+Y.create = (e, t) => new Y({
+	innerType: e,
+	typeName: $.ZodDefault,
+	defaultValue: typeof t.default == "function" ? t.default : () => t.default,
+	..._(t)
+});
+var X = class extends v {
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e), n = {
+			...t,
+			common: {
+				...t.common,
+				issues: []
+			}
+		}, i = this._def.innerType._parse({
+			data: n.data,
+			path: n.path,
+			parent: { ...n }
+		});
+		return p(i) ? i.then((e) => ({
+			status: "valid",
+			value: e.status === "valid" ? e.value : this._def.catchValue({
+				get error() {
+					return new r(n.common.issues);
+				},
+				input: n.data
+			})
+		})) : {
+			status: "valid",
+			value: i.status === "valid" ? i.value : this._def.catchValue({
+				get error() {
+					return new r(n.common.issues);
+				},
+				input: n.data
+			})
+		};
+	}
+	removeCatch() {
+		return this._def.innerType;
+	}
+};
+X.create = (e, t) => new X({
+	innerType: e,
+	typeName: $.ZodCatch,
+	catchValue: typeof t.catch == "function" ? t.catch : () => t.catch,
+	..._(t)
+});
+var Z = class extends v {
+	_parse(t) {
+		if (this._getType(t) !== e.nan) {
+			let n = this._getOrReturnCtx(t);
+			return d(n, {
+				code: i.invalid_type,
+				expected: e.nan,
+				received: n.parsedType
+			}), c;
+		}
+		return {
+			status: "valid",
+			value: t.data
+		};
+	}
+};
+Z.create = (e) => new Z({
+	typeName: $.ZodNaN,
+	..._(e)
+});
+var Me = class extends v {
+	_parse(e) {
+		let { ctx: t } = this._processInputParams(e), n = t.data;
+		return this._def.type._parse({
+			data: n,
+			path: t.path,
+			parent: t
+		});
+	}
+	unwrap() {
+		return this._def.type;
+	}
+}, Ne = class e extends v {
+	_parse(e) {
+		let { status: t, ctx: n } = this._processInputParams(e);
+		if (n.common.async) return (async () => {
+			let e = await this._def.in._parseAsync({
+				data: n.data,
+				path: n.path,
+				parent: n
+			});
+			return e.status === "aborted" ? c : e.status === "dirty" ? (t.dirty(), s(e.value)) : this._def.out._parseAsync({
+				data: e.value,
+				path: n.path,
+				parent: n
+			});
+		})();
+		{
+			let e = this._def.in._parseSync({
+				data: n.data,
+				path: n.path,
+				parent: n
+			});
+			return e.status === "aborted" ? c : e.status === "dirty" ? (t.dirty(), {
+				status: "dirty",
+				value: e.value
+			}) : this._def.out._parseSync({
+				data: e.value,
+				path: n.path,
+				parent: n
+			});
+		}
+	}
+	static create(t, n) {
+		return new e({
+			in: t,
+			out: n,
+			typeName: $.ZodPipeline
+		});
+	}
+}, Q = class extends v {
+	_parse(e) {
+		let t = this._def.innerType._parse(e), n = (e) => (m(e) && (e.value = Object.freeze(e.value)), e);
+		return p(t) ? t.then((e) => n(e)) : n(t);
+	}
+	unwrap() {
+		return this._def.innerType;
+	}
+};
+Q.create = (e, t) => new Q({
+	innerType: e,
+	typeName: $.ZodReadonly,
+	..._(t)
+}), N.lazycreate;
+var $;
+(function(e) {
+	e.ZodString = "ZodString", e.ZodNumber = "ZodNumber", e.ZodNaN = "ZodNaN", e.ZodBigInt = "ZodBigInt", e.ZodBoolean = "ZodBoolean", e.ZodDate = "ZodDate", e.ZodSymbol = "ZodSymbol", e.ZodUndefined = "ZodUndefined", e.ZodNull = "ZodNull", e.ZodAny = "ZodAny", e.ZodUnknown = "ZodUnknown", e.ZodNever = "ZodNever", e.ZodVoid = "ZodVoid", e.ZodArray = "ZodArray", e.ZodObject = "ZodObject", e.ZodUnion = "ZodUnion", e.ZodDiscriminatedUnion = "ZodDiscriminatedUnion", e.ZodIntersection = "ZodIntersection", e.ZodTuple = "ZodTuple", e.ZodRecord = "ZodRecord", e.ZodMap = "ZodMap", e.ZodSet = "ZodSet", e.ZodFunction = "ZodFunction", e.ZodLazy = "ZodLazy", e.ZodLiteral = "ZodLiteral", e.ZodEnum = "ZodEnum", e.ZodEffects = "ZodEffects", e.ZodNativeEnum = "ZodNativeEnum", e.ZodOptional = "ZodOptional", e.ZodNullable = "ZodNullable", e.ZodDefault = "ZodDefault", e.ZodCatch = "ZodCatch", e.ZodPromise = "ZodPromise", e.ZodBranded = "ZodBranded", e.ZodPipeline = "ZodPipeline", e.ZodReadonly = "ZodReadonly";
+})($ ||= {});
+var Pe = y.create, Fe = b.create;
+Z.create, x.create;
+var Ie = S.create;
+C.create, w.create, T.create, E.create, D.create, O.create, k.create, A.create, j.create;
+var Le = N.create;
+N.strictCreate, P.create, Oe.create, L.create, R.create, ke.create, z.create, B.create, Ae.create, V.create;
+var Re = H.create, ze = U.create;
+W.create, G.create, K.create, q.create, J.create, K.createWithPreprocess, Ne.create;
+var Be = {
+	string: ((e) => y.create({
+		...e,
+		coerce: !0
+	})),
+	number: ((e) => b.create({
+		...e,
+		coerce: !0
+	})),
+	boolean: ((e) => S.create({
+		...e,
+		coerce: !0
+	})),
+	bigint: ((e) => x.create({
+		...e,
+		coerce: !0
+	})),
+	date: ((e) => C.create({
+		...e,
+		coerce: !0
+	}))
+};
+//#endregion
+export { Ie as booleanType, Be as coerce, ze as enumType, Re as literalType, Fe as numberType, Le as objectType, Pe as stringType };
+
+//# sourceMappingURL=types.js.map