sunpeak 0.16.29 → 0.17.2

package/template/node_modules/.vite-mcp/deps/zod.js

@@ -0,0 +1,624 @@
+import { n as __exportAll } from "./chunk-BoAXSpZd.js";
+import { $ as ZodStringFormat, $n as uuidv6, $r as _regex, $t as int32, A as ZodJWT, An as readonly, Ar as _coercedNumber, At as check, B as ZodNull, Bn as superRefine, Br as _maxLength, Bt as e164, C as ZodExactOptional, Ci as config, Cn as object, Cr as checks_exports, Ct as _void, D as ZodIPv4, Dn as prefault, Dr as _coercedBigint, Dt as base64url, E as ZodGUID, En as pipe, Er as TimePrecision, Et as base64, F as ZodMap, Fn as strictObject, Fr as _includes, Ft as cuid2, G as ZodOptional, Gn as uint32, Gr as _multipleOf, Gt as float32, H as ZodNumber, Hn as templateLiteral, Hr as _mime, Ht as emoji, I as ZodNaN, In as string, Ir as _length, It as custom, J as ZodPromise, Jn as union, Jr as _nonpositive, Jt as hash, K as ZodPipe, Kn as uint64, Kr as _negative, Kt as float64, L as ZodNanoID, Ln as stringFormat, Lr as _lowercase, Lt as date, M as ZodLazy, Mn as refine, Mr as _endsWith, Mt as cidrv6, N as ZodLiteral, Nn as schemas_exports, Nr as _gt, Nt as codec, O as ZodIPv6, On as preprocess, Or as _coercedBoolean, Ot as bigint, P as ZodMAC, Pn as set, Pr as _gte, Pt as cuid, Q as ZodString, Qn as uuidv4, Qr as _property, Qt as int, R as ZodNever, Rn as stringbool, Rr as _lt, Rt as describe, S as ZodEnum, Si as NEVER, Sn as number, Sr as iso_exports, St as _undefined, T as ZodFunction, Tn as partialRecord, Tr as toJSONSchema, Tt as array, U as ZodNumberFormat, Un as transform, Ur as _minLength, Ut as exactOptional, V as ZodNullable, Vn as symbol, Vr as _maxSize, Vt as email, W as ZodObject, Wn as tuple, Wr as _minSize, Wt as file, X as ZodRecord, Xn as url, Xr as _overwrite, Xt as hostname, Y as ZodReadonly, Yn as unknown, Yr as _normalize, Yt as hex, Z as ZodSet, Zn as uuid, Zr as _positive, Zt as httpUrl, _ as ZodDefault, _i as prettifyError, _n as nativeEnum, _r as ZodISODate, _t as _default, a as ZodBigInt, ai as _trim, an as jwt, ar as encode, at as ZodType, b as ZodEmail, bi as util_exports, bn as nullable, br as ZodISOTime, bt as _instanceof, c as ZodCIDRv4, ci as $output, cn as lazy, cr as parseAsync, ct as ZodUUID, d as ZodCUID2, di as locales_exports, dn as looseRecord, dr as safeEncode, dt as ZodUnknown, ei as _size, en as int64, er as uuidv7, et as ZodSuccess, f as ZodCatch, fi as en_default, fn as mac, fr as safeEncodeAsync, ft as ZodVoid, g as ZodDate, gi as formatError, gn as nanoid, gr as ZodRealError, gt as _catch, h as ZodCustomStringFormat, hi as flattenError, hn as nan, hr as ZodError, ht as _ZodString, i as ZodBase64URL, ii as _toUpperCase, in as json, ir as decodeAsync, it as ZodTuple, j as ZodKSUID, jn as record, jr as _coercedString, jt as cidrv4, k as ZodIntersection, kn as promise, kr as _coercedDate, kt as boolean, l as ZodCIDRv6, li as globalRegistry, ln as literal, lr as safeDecode, lt as ZodUndefined, m as ZodCustom, mn as meta, mr as safeParseAsync, mt as ZodXor, n as ZodArray, ni as _startsWith, nn as ipv4, nr as xor, nt as ZodTemplateLiteral, o as ZodBigIntFormat, oi as _uppercase, on as keyof, or as encodeAsync, ot as ZodULID, p as ZodCodec, pi as regexes_exports, pn as map, pr as safeParse, pt as ZodXID, q as ZodPrefault, qn as ulid, qr as _nonnegative, qt as guid, r as ZodBase64, ri as _toLowerCase, rn as ipv6, rr as decode, rt as ZodTransform, s as ZodBoolean, si as $input, sn as ksuid, sr as parse, st as ZodURL, t as ZodAny, ti as _slugify, tn as intersection, tr as xid, tt as ZodSymbol, u as ZodCUID, ui as registry, un as looseObject, ur as safeDecodeAsync, ut as ZodUnion, v as ZodDiscriminatedUnion, vi as treeifyError, vn as never, vr as ZodISODateTime, vt as _enum, w as ZodFile, wn as optional, wr as core_exports, wt as any, x as ZodEmoji, xi as $brand, xn as nullish, xt as _null, y as ZodE164, yi as clone, yn as nonoptional, yr as ZodISODuration, yt as _function, z as ZodNonOptional, zn as success, zr as _lte, zt as discriminatedUnion } from "./schemas-NsgmY9QV.js";
+//#region ../../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/compat.js
+/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
+var ZodIssueCode = {
+	invalid_type: "invalid_type",
+	too_big: "too_big",
+	too_small: "too_small",
+	invalid_format: "invalid_format",
+	not_multiple_of: "not_multiple_of",
+	unrecognized_keys: "unrecognized_keys",
+	invalid_union: "invalid_union",
+	invalid_key: "invalid_key",
+	invalid_element: "invalid_element",
+	invalid_value: "invalid_value",
+	custom: "custom"
+};
+/** @deprecated Use `z.config(params)` instead. */
+function setErrorMap(map) {
+	config({ customError: map });
+}
+/** @deprecated Use `z.config()` instead. */
+function getErrorMap() {
+	return config().customError;
+}
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind) {})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/from-json-schema.js
+var z = {
+	...schemas_exports,
+	...checks_exports,
+	iso: iso_exports
+};
+var RECOGNIZED_KEYS = new Set([
+	"$schema",
+	"$ref",
+	"$defs",
+	"definitions",
+	"$id",
+	"id",
+	"$comment",
+	"$anchor",
+	"$vocabulary",
+	"$dynamicRef",
+	"$dynamicAnchor",
+	"type",
+	"enum",
+	"const",
+	"anyOf",
+	"oneOf",
+	"allOf",
+	"not",
+	"properties",
+	"required",
+	"additionalProperties",
+	"patternProperties",
+	"propertyNames",
+	"minProperties",
+	"maxProperties",
+	"items",
+	"prefixItems",
+	"additionalItems",
+	"minItems",
+	"maxItems",
+	"uniqueItems",
+	"contains",
+	"minContains",
+	"maxContains",
+	"minLength",
+	"maxLength",
+	"pattern",
+	"format",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf",
+	"description",
+	"default",
+	"contentEncoding",
+	"contentMediaType",
+	"contentSchema",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"if",
+	"then",
+	"else",
+	"dependentSchemas",
+	"dependentRequired",
+	"nullable",
+	"readOnly"
+]);
+function detectVersion(schema, defaultTarget) {
+	const $schema = schema.$schema;
+	if ($schema === "https://json-schema.org/draft/2020-12/schema") return "draft-2020-12";
+	if ($schema === "http://json-schema.org/draft-07/schema#") return "draft-7";
+	if ($schema === "http://json-schema.org/draft-04/schema#") return "draft-4";
+	return defaultTarget ?? "draft-2020-12";
+}
+function resolveRef(ref, ctx) {
+	if (!ref.startsWith("#")) throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
+	const path = ref.slice(1).split("/").filter(Boolean);
+	if (path.length === 0) return ctx.rootSchema;
+	const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
+	if (path[0] === defsKey) {
+		const key = path[1];
+		if (!key || !ctx.defs[key]) throw new Error(`Reference not found: ${ref}`);
+		return ctx.defs[key];
+	}
+	throw new Error(`Reference not found: ${ref}`);
+}
+function convertBaseSchema(schema, ctx) {
+	if (schema.not !== void 0) {
+		if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) return z.never();
+		throw new Error("not is not supported in Zod (except { not: {} } for never)");
+	}
+	if (schema.unevaluatedItems !== void 0) throw new Error("unevaluatedItems is not supported");
+	if (schema.unevaluatedProperties !== void 0) throw new Error("unevaluatedProperties is not supported");
+	if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) throw new Error("Conditional schemas (if/then/else) are not supported");
+	if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) throw new Error("dependentSchemas and dependentRequired are not supported");
+	if (schema.$ref) {
+		const refPath = schema.$ref;
+		if (ctx.refs.has(refPath)) return ctx.refs.get(refPath);
+		if (ctx.processing.has(refPath)) return z.lazy(() => {
+			if (!ctx.refs.has(refPath)) throw new Error(`Circular reference not resolved: ${refPath}`);
+			return ctx.refs.get(refPath);
+		});
+		ctx.processing.add(refPath);
+		const zodSchema = convertSchema(resolveRef(refPath, ctx), ctx);
+		ctx.refs.set(refPath, zodSchema);
+		ctx.processing.delete(refPath);
+		return zodSchema;
+	}
+	if (schema.enum !== void 0) {
+		const enumValues = schema.enum;
+		if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) return z.null();
+		if (enumValues.length === 0) return z.never();
+		if (enumValues.length === 1) return z.literal(enumValues[0]);
+		if (enumValues.every((v) => typeof v === "string")) return z.enum(enumValues);
+		const literalSchemas = enumValues.map((v) => z.literal(v));
+		if (literalSchemas.length < 2) return literalSchemas[0];
+		return z.union([
+			literalSchemas[0],
+			literalSchemas[1],
+			...literalSchemas.slice(2)
+		]);
+	}
+	if (schema.const !== void 0) return z.literal(schema.const);
+	const type = schema.type;
+	if (Array.isArray(type)) {
+		const typeSchemas = type.map((t) => {
+			return convertBaseSchema({
+				...schema,
+				type: t
+			}, ctx);
+		});
+		if (typeSchemas.length === 0) return z.never();
+		if (typeSchemas.length === 1) return typeSchemas[0];
+		return z.union(typeSchemas);
+	}
+	if (!type) return z.any();
+	let zodSchema;
+	switch (type) {
+		case "string": {
+			let stringSchema = z.string();
+			if (schema.format) {
+				const format = schema.format;
+				if (format === "email") stringSchema = stringSchema.check(z.email());
+				else if (format === "uri" || format === "uri-reference") stringSchema = stringSchema.check(z.url());
+				else if (format === "uuid" || format === "guid") stringSchema = stringSchema.check(z.uuid());
+				else if (format === "date-time") stringSchema = stringSchema.check(z.iso.datetime());
+				else if (format === "date") stringSchema = stringSchema.check(z.iso.date());
+				else if (format === "time") stringSchema = stringSchema.check(z.iso.time());
+				else if (format === "duration") stringSchema = stringSchema.check(z.iso.duration());
+				else if (format === "ipv4") stringSchema = stringSchema.check(z.ipv4());
+				else if (format === "ipv6") stringSchema = stringSchema.check(z.ipv6());
+				else if (format === "mac") stringSchema = stringSchema.check(z.mac());
+				else if (format === "cidr") stringSchema = stringSchema.check(z.cidrv4());
+				else if (format === "cidr-v6") stringSchema = stringSchema.check(z.cidrv6());
+				else if (format === "base64") stringSchema = stringSchema.check(z.base64());
+				else if (format === "base64url") stringSchema = stringSchema.check(z.base64url());
+				else if (format === "e164") stringSchema = stringSchema.check(z.e164());
+				else if (format === "jwt") stringSchema = stringSchema.check(z.jwt());
+				else if (format === "emoji") stringSchema = stringSchema.check(z.emoji());
+				else if (format === "nanoid") stringSchema = stringSchema.check(z.nanoid());
+				else if (format === "cuid") stringSchema = stringSchema.check(z.cuid());
+				else if (format === "cuid2") stringSchema = stringSchema.check(z.cuid2());
+				else if (format === "ulid") stringSchema = stringSchema.check(z.ulid());
+				else if (format === "xid") stringSchema = stringSchema.check(z.xid());
+				else if (format === "ksuid") stringSchema = stringSchema.check(z.ksuid());
+			}
+			if (typeof schema.minLength === "number") stringSchema = stringSchema.min(schema.minLength);
+			if (typeof schema.maxLength === "number") stringSchema = stringSchema.max(schema.maxLength);
+			if (schema.pattern) stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+			zodSchema = stringSchema;
+			break;
+		}
+		case "number":
+		case "integer": {
+			let numberSchema = type === "integer" ? z.number().int() : z.number();
+			if (typeof schema.minimum === "number") numberSchema = numberSchema.min(schema.minimum);
+			if (typeof schema.maximum === "number") numberSchema = numberSchema.max(schema.maximum);
+			if (typeof schema.exclusiveMinimum === "number") numberSchema = numberSchema.gt(schema.exclusiveMinimum);
+			else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") numberSchema = numberSchema.gt(schema.minimum);
+			if (typeof schema.exclusiveMaximum === "number") numberSchema = numberSchema.lt(schema.exclusiveMaximum);
+			else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") numberSchema = numberSchema.lt(schema.maximum);
+			if (typeof schema.multipleOf === "number") numberSchema = numberSchema.multipleOf(schema.multipleOf);
+			zodSchema = numberSchema;
+			break;
+		}
+		case "boolean":
+			zodSchema = z.boolean();
+			break;
+		case "null":
+			zodSchema = z.null();
+			break;
+		case "object": {
+			const shape = {};
+			const properties = schema.properties || {};
+			const requiredSet = new Set(schema.required || []);
+			for (const [key, propSchema] of Object.entries(properties)) {
+				const propZodSchema = convertSchema(propSchema, ctx);
+				shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
+			}
+			if (schema.propertyNames) {
+				const keySchema = convertSchema(schema.propertyNames, ctx);
+				const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
+				if (Object.keys(shape).length === 0) {
+					zodSchema = z.record(keySchema, valueSchema);
+					break;
+				}
+				const objectSchema = z.object(shape).passthrough();
+				const recordSchema = z.looseRecord(keySchema, valueSchema);
+				zodSchema = z.intersection(objectSchema, recordSchema);
+				break;
+			}
+			if (schema.patternProperties) {
+				const patternProps = schema.patternProperties;
+				const patternKeys = Object.keys(patternProps);
+				const looseRecords = [];
+				for (const pattern of patternKeys) {
+					const patternValue = convertSchema(patternProps[pattern], ctx);
+					const keySchema = z.string().regex(new RegExp(pattern));
+					looseRecords.push(z.looseRecord(keySchema, patternValue));
+				}
+				const schemasToIntersect = [];
+				if (Object.keys(shape).length > 0) schemasToIntersect.push(z.object(shape).passthrough());
+				schemasToIntersect.push(...looseRecords);
+				if (schemasToIntersect.length === 0) zodSchema = z.object({}).passthrough();
+				else if (schemasToIntersect.length === 1) zodSchema = schemasToIntersect[0];
+				else {
+					let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+					for (let i = 2; i < schemasToIntersect.length; i++) result = z.intersection(result, schemasToIntersect[i]);
+					zodSchema = result;
+				}
+				break;
+			}
+			const objectSchema = z.object(shape);
+			if (schema.additionalProperties === false) zodSchema = objectSchema.strict();
+			else if (typeof schema.additionalProperties === "object") zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+			else zodSchema = objectSchema.passthrough();
+			break;
+		}
+		case "array": {
+			const prefixItems = schema.prefixItems;
+			const items = schema.items;
+			if (prefixItems && Array.isArray(prefixItems)) {
+				const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
+				const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
+				if (rest) zodSchema = z.tuple(tupleItems).rest(rest);
+				else zodSchema = z.tuple(tupleItems);
+				if (typeof schema.minItems === "number") zodSchema = zodSchema.check(z.minLength(schema.minItems));
+				if (typeof schema.maxItems === "number") zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+			} else if (Array.isArray(items)) {
+				const tupleItems = items.map((item) => convertSchema(item, ctx));
+				const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
+				if (rest) zodSchema = z.tuple(tupleItems).rest(rest);
+				else zodSchema = z.tuple(tupleItems);
+				if (typeof schema.minItems === "number") zodSchema = zodSchema.check(z.minLength(schema.minItems));
+				if (typeof schema.maxItems === "number") zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+			} else if (items !== void 0) {
+				const element = convertSchema(items, ctx);
+				let arraySchema = z.array(element);
+				if (typeof schema.minItems === "number") arraySchema = arraySchema.min(schema.minItems);
+				if (typeof schema.maxItems === "number") arraySchema = arraySchema.max(schema.maxItems);
+				zodSchema = arraySchema;
+			} else zodSchema = z.array(z.any());
+			break;
+		}
+		default: throw new Error(`Unsupported type: ${type}`);
+	}
+	if (schema.description) zodSchema = zodSchema.describe(schema.description);
+	if (schema.default !== void 0) zodSchema = zodSchema.default(schema.default);
+	return zodSchema;
+}
+function convertSchema(schema, ctx) {
+	if (typeof schema === "boolean") return schema ? z.any() : z.never();
+	let baseSchema = convertBaseSchema(schema, ctx);
+	const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
+	if (schema.anyOf && Array.isArray(schema.anyOf)) {
+		const options = schema.anyOf.map((s) => convertSchema(s, ctx));
+		const anyOfUnion = z.union(options);
+		baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+	}
+	if (schema.oneOf && Array.isArray(schema.oneOf)) {
+		const options = schema.oneOf.map((s) => convertSchema(s, ctx));
+		const oneOfUnion = z.xor(options);
+		baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+	}
+	if (schema.allOf && Array.isArray(schema.allOf)) if (schema.allOf.length === 0) baseSchema = hasExplicitType ? baseSchema : z.any();
+	else {
+		let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+		const startIdx = hasExplicitType ? 0 : 1;
+		for (let i = startIdx; i < schema.allOf.length; i++) result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
+		baseSchema = result;
+	}
+	if (schema.nullable === true && ctx.version === "openapi-3.0") baseSchema = z.nullable(baseSchema);
+	if (schema.readOnly === true) baseSchema = z.readonly(baseSchema);
+	const extraMeta = {};
+	for (const key of [
+		"$id",
+		"id",
+		"$comment",
+		"$anchor",
+		"$vocabulary",
+		"$dynamicRef",
+		"$dynamicAnchor"
+	]) if (key in schema) extraMeta[key] = schema[key];
+	for (const key of [
+		"contentEncoding",
+		"contentMediaType",
+		"contentSchema"
+	]) if (key in schema) extraMeta[key] = schema[key];
+	for (const key of Object.keys(schema)) if (!RECOGNIZED_KEYS.has(key)) extraMeta[key] = schema[key];
+	if (Object.keys(extraMeta).length > 0) ctx.registry.add(baseSchema, extraMeta);
+	return baseSchema;
+}
+/**
+* Converts a JSON Schema to a Zod schema. This function should be considered semi-experimental. It's behavior is liable to change. */
+function fromJSONSchema(schema, params) {
+	if (typeof schema === "boolean") return schema ? z.any() : z.never();
+	return convertSchema(schema, {
+		version: detectVersion(schema, params?.defaultTarget),
+		defs: schema.$defs || schema.definitions || {},
+		refs: /* @__PURE__ */ new Map(),
+		processing: /* @__PURE__ */ new Set(),
+		rootSchema: schema,
+		registry: params?.registry ?? globalRegistry
+	});
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/coerce.js
+var coerce_exports = /* @__PURE__ */ __exportAll({
+	bigint: () => bigint$1,
+	boolean: () => boolean$1,
+	date: () => date$1,
+	number: () => number$1,
+	string: () => string$1
+});
+function string$1(params) {
+	return _coercedString(ZodString, params);
+}
+function number$1(params) {
+	return _coercedNumber(ZodNumber, params);
+}
+function boolean$1(params) {
+	return _coercedBoolean(ZodBoolean, params);
+}
+function bigint$1(params) {
+	return _coercedBigint(ZodBigInt, params);
+}
+function date$1(params) {
+	return _coercedDate(ZodDate, params);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/external.js
+var external_exports = /* @__PURE__ */ __exportAll({
+	$brand: () => $brand,
+	$input: () => $input,
+	$output: () => $output,
+	NEVER: () => NEVER,
+	TimePrecision: () => TimePrecision,
+	ZodAny: () => ZodAny,
+	ZodArray: () => ZodArray,
+	ZodBase64: () => ZodBase64,
+	ZodBase64URL: () => ZodBase64URL,
+	ZodBigInt: () => ZodBigInt,
+	ZodBigIntFormat: () => ZodBigIntFormat,
+	ZodBoolean: () => ZodBoolean,
+	ZodCIDRv4: () => ZodCIDRv4,
+	ZodCIDRv6: () => ZodCIDRv6,
+	ZodCUID: () => ZodCUID,
+	ZodCUID2: () => ZodCUID2,
+	ZodCatch: () => ZodCatch,
+	ZodCodec: () => ZodCodec,
+	ZodCustom: () => ZodCustom,
+	ZodCustomStringFormat: () => ZodCustomStringFormat,
+	ZodDate: () => ZodDate,
+	ZodDefault: () => ZodDefault,
+	ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+	ZodE164: () => ZodE164,
+	ZodEmail: () => ZodEmail,
+	ZodEmoji: () => ZodEmoji,
+	ZodEnum: () => ZodEnum,
+	ZodError: () => ZodError,
+	ZodExactOptional: () => ZodExactOptional,
+	ZodFile: () => ZodFile,
+	ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+	ZodFunction: () => ZodFunction,
+	ZodGUID: () => ZodGUID,
+	ZodIPv4: () => ZodIPv4,
+	ZodIPv6: () => ZodIPv6,
+	ZodISODate: () => ZodISODate,
+	ZodISODateTime: () => ZodISODateTime,
+	ZodISODuration: () => ZodISODuration,
+	ZodISOTime: () => ZodISOTime,
+	ZodIntersection: () => ZodIntersection,
+	ZodIssueCode: () => ZodIssueCode,
+	ZodJWT: () => ZodJWT,
+	ZodKSUID: () => ZodKSUID,
+	ZodLazy: () => ZodLazy,
+	ZodLiteral: () => ZodLiteral,
+	ZodMAC: () => ZodMAC,
+	ZodMap: () => ZodMap,
+	ZodNaN: () => ZodNaN,
+	ZodNanoID: () => ZodNanoID,
+	ZodNever: () => ZodNever,
+	ZodNonOptional: () => ZodNonOptional,
+	ZodNull: () => ZodNull,
+	ZodNullable: () => ZodNullable,
+	ZodNumber: () => ZodNumber,
+	ZodNumberFormat: () => ZodNumberFormat,
+	ZodObject: () => ZodObject,
+	ZodOptional: () => ZodOptional,
+	ZodPipe: () => ZodPipe,
+	ZodPrefault: () => ZodPrefault,
+	ZodPromise: () => ZodPromise,
+	ZodReadonly: () => ZodReadonly,
+	ZodRealError: () => ZodRealError,
+	ZodRecord: () => ZodRecord,
+	ZodSet: () => ZodSet,
+	ZodString: () => ZodString,
+	ZodStringFormat: () => ZodStringFormat,
+	ZodSuccess: () => ZodSuccess,
+	ZodSymbol: () => ZodSymbol,
+	ZodTemplateLiteral: () => ZodTemplateLiteral,
+	ZodTransform: () => ZodTransform,
+	ZodTuple: () => ZodTuple,
+	ZodType: () => ZodType,
+	ZodULID: () => ZodULID,
+	ZodURL: () => ZodURL,
+	ZodUUID: () => ZodUUID,
+	ZodUndefined: () => ZodUndefined,
+	ZodUnion: () => ZodUnion,
+	ZodUnknown: () => ZodUnknown,
+	ZodVoid: () => ZodVoid,
+	ZodXID: () => ZodXID,
+	ZodXor: () => ZodXor,
+	_ZodString: () => _ZodString,
+	_default: () => _default,
+	_function: () => _function,
+	any: () => any,
+	array: () => array,
+	base64: () => base64,
+	base64url: () => base64url,
+	bigint: () => bigint,
+	boolean: () => boolean,
+	catch: () => _catch,
+	check: () => check,
+	cidrv4: () => cidrv4,
+	cidrv6: () => cidrv6,
+	clone: () => clone,
+	codec: () => codec,
+	coerce: () => coerce_exports,
+	config: () => config,
+	core: () => core_exports,
+	cuid: () => cuid,
+	cuid2: () => cuid2,
+	custom: () => custom,
+	date: () => date,
+	decode: () => decode,
+	decodeAsync: () => decodeAsync,
+	describe: () => describe,
+	discriminatedUnion: () => discriminatedUnion,
+	e164: () => e164,
+	email: () => email,
+	emoji: () => emoji,
+	encode: () => encode,
+	encodeAsync: () => encodeAsync,
+	endsWith: () => _endsWith,
+	enum: () => _enum,
+	exactOptional: () => exactOptional,
+	file: () => file,
+	flattenError: () => flattenError,
+	float32: () => float32,
+	float64: () => float64,
+	formatError: () => formatError,
+	fromJSONSchema: () => fromJSONSchema,
+	function: () => _function,
+	getErrorMap: () => getErrorMap,
+	globalRegistry: () => globalRegistry,
+	gt: () => _gt,
+	gte: () => _gte,
+	guid: () => guid,
+	hash: () => hash,
+	hex: () => hex,
+	hostname: () => hostname,
+	httpUrl: () => httpUrl,
+	includes: () => _includes,
+	instanceof: () => _instanceof,
+	int: () => int,
+	int32: () => int32,
+	int64: () => int64,
+	intersection: () => intersection,
+	ipv4: () => ipv4,
+	ipv6: () => ipv6,
+	iso: () => iso_exports,
+	json: () => json,
+	jwt: () => jwt,
+	keyof: () => keyof,
+	ksuid: () => ksuid,
+	lazy: () => lazy,
+	length: () => _length,
+	literal: () => literal,
+	locales: () => locales_exports,
+	looseObject: () => looseObject,
+	looseRecord: () => looseRecord,
+	lowercase: () => _lowercase,
+	lt: () => _lt,
+	lte: () => _lte,
+	mac: () => mac,
+	map: () => map,
+	maxLength: () => _maxLength,
+	maxSize: () => _maxSize,
+	meta: () => meta,
+	mime: () => _mime,
+	minLength: () => _minLength,
+	minSize: () => _minSize,
+	multipleOf: () => _multipleOf,
+	nan: () => nan,
+	nanoid: () => nanoid,
+	nativeEnum: () => nativeEnum,
+	negative: () => _negative,
+	never: () => never,
+	nonnegative: () => _nonnegative,
+	nonoptional: () => nonoptional,
+	nonpositive: () => _nonpositive,
+	normalize: () => _normalize,
+	null: () => _null,
+	nullable: () => nullable,
+	nullish: () => nullish,
+	number: () => number,
+	object: () => object,
+	optional: () => optional,
+	overwrite: () => _overwrite,
+	parse: () => parse,
+	parseAsync: () => parseAsync,
+	partialRecord: () => partialRecord,
+	pipe: () => pipe,
+	positive: () => _positive,
+	prefault: () => prefault,
+	preprocess: () => preprocess,
+	prettifyError: () => prettifyError,
+	promise: () => promise,
+	property: () => _property,
+	readonly: () => readonly,
+	record: () => record,
+	refine: () => refine,
+	regex: () => _regex,
+	regexes: () => regexes_exports,
+	registry: () => registry,
+	safeDecode: () => safeDecode,
+	safeDecodeAsync: () => safeDecodeAsync,
+	safeEncode: () => safeEncode,
+	safeEncodeAsync: () => safeEncodeAsync,
+	safeParse: () => safeParse,
+	safeParseAsync: () => safeParseAsync,
+	set: () => set,
+	setErrorMap: () => setErrorMap,
+	size: () => _size,
+	slugify: () => _slugify,
+	startsWith: () => _startsWith,
+	strictObject: () => strictObject,
+	string: () => string,
+	stringFormat: () => stringFormat,
+	stringbool: () => stringbool,
+	success: () => success,
+	superRefine: () => superRefine,
+	symbol: () => symbol,
+	templateLiteral: () => templateLiteral,
+	toJSONSchema: () => toJSONSchema,
+	toLowerCase: () => _toLowerCase,
+	toUpperCase: () => _toUpperCase,
+	transform: () => transform,
+	treeifyError: () => treeifyError,
+	trim: () => _trim,
+	tuple: () => tuple,
+	uint32: () => uint32,
+	uint64: () => uint64,
+	ulid: () => ulid,
+	undefined: () => _undefined,
+	union: () => union,
+	unknown: () => unknown,
+	uppercase: () => _uppercase,
+	url: () => url,
+	util: () => util_exports,
+	uuid: () => uuid,
+	uuidv4: () => uuidv4,
+	uuidv6: () => uuidv6,
+	uuidv7: () => uuidv7,
+	void: () => _void,
+	xid: () => xid,
+	xor: () => xor
+});
+config(en_default());
+//#endregion
+//#region ../../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/index.js
+var zod_default = external_exports;
+//#endregion
+export { $brand, $input, $output, NEVER, TimePrecision, ZodAny, ZodArray, ZodBase64, ZodBase64URL, ZodBigInt, ZodBigIntFormat, ZodBoolean, ZodCIDRv4, ZodCIDRv6, ZodCUID, ZodCUID2, ZodCatch, ZodCodec, ZodCustom, ZodCustomStringFormat, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodE164, ZodEmail, ZodEmoji, ZodEnum, ZodError, ZodExactOptional, ZodFile, ZodFirstPartyTypeKind, ZodFunction, ZodGUID, ZodIPv4, ZodIPv6, ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, ZodIntersection, ZodIssueCode, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMAC, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPromise, ZodReadonly, ZodRealError, ZodRecord, ZodSet, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodType, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, ZodXor, _ZodString, _default, _function, _function as function, any, array, base64, base64url, bigint, boolean, _catch as catch, check, cidrv4, cidrv6, clone, codec, coerce_exports as coerce, config, core_exports as core, cuid, cuid2, custom, date, decode, decodeAsync, zod_default as default, describe, discriminatedUnion, e164, email, emoji, encode, encodeAsync, _endsWith as endsWith, _enum as enum, exactOptional, file, flattenError, float32, float64, formatError, fromJSONSchema, getErrorMap, globalRegistry, _gt as gt, _gte as gte, guid, hash, hex, hostname, httpUrl, _includes as includes, _instanceof as instanceof, int, int32, int64, intersection, ipv4, ipv6, iso_exports as iso, json, jwt, keyof, ksuid, lazy, _length as length, literal, locales_exports as locales, looseObject, looseRecord, _lowercase as lowercase, _lt as lt, _lte as lte, mac, map, _maxLength as maxLength, _maxSize as maxSize, meta, _mime as mime, _minLength as minLength, _minSize as minSize, _multipleOf as multipleOf, nan, nanoid, nativeEnum, _negative as negative, never, _nonnegative as nonnegative, nonoptional, _nonpositive as nonpositive, _normalize as normalize, _null as null, nullable, nullish, number, object, optional, _overwrite as overwrite, parse, parseAsync, partialRecord, pipe, _positive as positive, prefault, preprocess, prettifyError, promise, _property as property, readonly, record, refine, _regex as regex, regexes_exports as regexes, registry, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, setErrorMap, _size as size, _slugify as slugify, _startsWith as startsWith, strictObject, string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, toJSONSchema, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, transform, treeifyError, _trim as trim, tuple, uint32, uint64, ulid, _undefined as undefined, union, unknown, _uppercase as uppercase, url, util_exports as util, uuid, uuidv4, uuidv6, uuidv7, _void as void, xid, xor, external_exports as z };
+
+//# sourceMappingURL=zod.js.map