surreal-zod 0.0.0-alpha.10 → 0.0.0-alpha.12

package/lib/zod/schema.js

@@ -1,180 +1,2014 @@
-/** biome-ignore-all lint/suspicious/noExplicitAny: needed for conversion */
-/** biome-ignore-all lint/style/noNonNullAssertion: needed for conversion */
-import { BoundQuery, escapeIdent, RecordId, surql, Table, } from "surrealdb";
+import { BoundQuery, DateTime, Duration, escapeIdent, RecordId, StringRecordId, surql, Uuid, Table, } from "surrealdb";
 import * as core from "zod/v4/core";
 import * as classic from "zod/v4";
-import { defineTable, inferSurrealType, tableToSurql, } from "../surql";
-export const SurrealZodType = core.$constructor("SurrealZodType", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
+import {} from "zod/v4/core";
+import { inferSurrealType, inlineQueryParameters, tableToSurql, } from "../surql";
+import * as _core_ from "./core";
+import { assignParsingMethods, } from "./parse";
+import { allProcessors } from "./json-schema";
+export const ZodSurrealType = core.$constructor("ZodSurrealType", (inst, def) => {
+    // @ts-expect-error
     core.$ZodType.init(inst, def);
-    // Casting as _surreal.type is built while the schema is initialized
     inst._zod.def.surreal ??= {};
+    Object.assign(inst["~standard"], {
+        jsonSchema: {
+            input: core.createStandardJSONSchemaMethod(
+            // Not overriding json schema stuff
+            inst, "input"),
+            output: core.createStandardJSONSchemaMethod(
+            // Not overriding json schema stuff
+            inst, "output"),
+        },
+    });
+    inst.toJSONSchema = core.createToJSONSchemaMethod(inst, {});
     // base methods
-    inst.clone = (def, params) => core.clone(inst, def, params);
-    // parsing
-    inst.parse = (data, params) => {
-        return core.parse(inst, data, params);
+    inst.check = (...checks) => {
+        return inst.clone(core.util.mergeDefs(def, {
+            checks: [
+                ...(def.checks ?? []),
+                ...checks.map((ch) => typeof ch === "function"
+                    ? {
+                        _zod: { check: ch, def: { check: "custom" }, onattach: [] },
+                    }
+                    : ch),
+            ],
+        }), {
+            parent: true,
+        });
     };
-    // inst.safeParse = (data, params) => {
-    //   return core.safeParse(inst, data, params);
-    // };
+    inst.with = inst.check;
+    inst.clone = (def, params) => core.clone(inst, def, params);
+    inst.brand = () => inst;
+    inst.register = ((reg, meta) => {
+        reg.add(inst, meta);
+        return inst;
+    });
+    assignParsingMethods(inst);
     // wrappers
     inst.optional = () => optional(inst);
-    inst.nonoptional = () => nonoptional(inst);
+    inst.exactOptional = () => exactOptional(inst);
     inst.nullable = () => nullable(inst);
-    inst.nullish = () => nullish(inst);
+    inst.nullish = () => optional(nullable(inst));
+    inst.nonoptional = (params) => nonoptional(inst, params);
+    inst.array = () => array(inst);
+    inst.or = (arg) => union([inst, arg]);
+    inst.and = (arg) => intersection(inst, arg);
+    inst.transform = (tx) => pipe(inst, transform(tx));
+    inst.default = (def) => _default(inst, def);
+    inst.prefault = (def) => prefault(inst, def);
+    // inst.coalesce = (def, params) => coalesce(inst, def, params);
+    inst.catch = (params) => _catch(inst, params);
+    inst.pipe = (target) => pipe(inst, target);
+    inst.readonly = () => readonly(inst);
+    return inst;
+});
+export const ZodSurrealField = core.$constructor("ZodSurrealField", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodType.init(inst, def);
+    def.surreal.field ??= {};
+    const isField = inst._zod.traits.size === 2;
+    if (def.surreal.field.default) {
+        inst._zod.optin = "optional";
+        inst._zod.optout = "optional";
+        inst._zod.dboptin = "optional";
+    }
+    assignParsingMethods(inst);
+    // ----------- Database Only Methods -----------
+    inst.$default = (value) => {
+        return new ZodSurrealField({
+            type: "field",
+            ...(isField ? inst._zod.def : {}),
+            innerType: isField ? inst._zod.def.innerType : inst,
+            surreal: {
+                ...(isField ? inst._zod.def.surreal : {}),
+                field: {
+                    ...(isField ? inst._zod.def.surreal.field : {}),
+                    default: {
+                        value: value instanceof BoundQuery ? value : surql `${value}`,
+                        always: false,
+                        parse: false,
+                    },
+                },
+            },
+        });
+    };
+    inst.$prefault = (value) => {
+        return new ZodSurrealField({
+            type: "field",
+            ...(isField ? inst._zod.def : {}),
+            innerType: isField ? inst._zod.def.innerType : inst,
+            surreal: {
+                ...(isField ? inst._zod.def.surreal : {}),
+                field: {
+                    ...(isField ? inst._zod.def.surreal.field : {}),
+                    default: {
+                        value: value instanceof BoundQuery ? value : surql `${value}`,
+                        always: false,
+                        parse: true,
+                    },
+                },
+            },
+        });
+    };
+    inst.$defaultAlways = (value) => {
+        return new ZodSurrealField({
+            type: "field",
+            ...(isField ? inst._zod.def : {}),
+            innerType: isField ? inst._zod.def.innerType : inst,
+            surreal: {
+                ...(isField ? inst._zod.def.surreal : {}),
+                field: {
+                    ...(isField ? inst._zod.def.surreal.field : {}),
+                    default: {
+                        value: value instanceof BoundQuery ? value : surql `${value}`,
+                        always: true,
+                    },
+                },
+            },
+        });
+    };
+    inst.$prefaultAlways = (value) => {
+        return new ZodSurrealField({
+            type: "field",
+            ...(isField ? inst._zod.def : {}),
+            innerType: isField ? inst._zod.def.innerType : inst,
+            surreal: {
+                ...(isField ? inst._zod.def.surreal : {}),
+                field: {
+                    ...(isField ? inst._zod.def.surreal.field : {}),
+                    default: {
+                        value: value instanceof BoundQuery ? value : surql `${value}`,
+                        always: true,
+                        parse: true,
+                    },
+                },
+            },
+        });
+    };
+    inst.$readonly = (readonly = true) => {
+        return new ZodSurrealField({
+            type: "field",
+            ...(isField ? inst._zod.def : {}),
+            innerType: isField ? inst._zod.def.innerType : inst,
+            surreal: {
+                ...(isField ? inst._zod.def.surreal : {}),
+                field: {
+                    ...inst._zod.def.surreal.field,
+                    readonly,
+                },
+            },
+        });
+    };
+    inst.$comment = (comment) => {
+        return new ZodSurrealField({
+            type: "field",
+            ...(isField ? inst._zod.def : {}),
+            innerType: isField ? inst._zod.def.innerType : inst,
+            surreal: {
+                ...(isField ? inst._zod.def.surreal : {}),
+                field: {
+                    ...(isField ? inst._zod.def.surreal.field : {}),
+                    comment,
+                },
+            },
+        });
+    };
+    inst.$assert = (assert) => {
+        return new ZodSurrealField({
+            type: "field",
+            ...(isField ? inst._zod.def : {}),
+            innerType: isField ? inst._zod.def.innerType : inst,
+            surreal: {
+                ...(isField ? inst._zod.def.surreal : {}),
+                field: {
+                    ...(isField ? inst._zod.def.surreal.field : {}),
+                    assert,
+                },
+            },
+        });
+    };
+    inst.$value = (value) => {
+        return new ZodSurrealField({
+            type: "field",
+            ...(isField ? inst._zod.def : {}),
+            innerType: isField ? inst._zod.def.innerType : inst,
+            surreal: {
+                ...(isField ? inst._zod.def.surreal : {}),
+                field: {
+                    ...(isField ? inst._zod.def.surreal.field : {}),
+                    value,
+                },
+            },
+        });
+    };
+    inst.unwrap = () => inst._zod.def.innerType;
+    if (isField) {
+        inst._zod.parse = (payload, ctx) => {
+            if (ctx.direction === "backward") {
+                return def.innerType._zod.run(payload, ctx);
+            }
+            // .default/.prefault take precedence
+            if (def.innerType._zod.optin === "optional") {
+                const result = def.innerType._zod.run(payload, ctx);
+                if (result instanceof Promise)
+                    return result.then((r) => {
+                        if (r.issues.length && payload.value === undefined) {
+                            return { issues: [], value: undefined };
+                        }
+                        return result;
+                    });
+                if (result.issues.length && payload.value === undefined) {
+                    return { issues: [], value: undefined };
+                }
+                return result;
+            }
+            // If database default is to be resolved
+            if (def.surreal.field.default && payload.value === undefined) {
+                if (!ctx.db) {
+                    return payload;
+                }
+                return ctx.db
+                    .query(`{ ${inlineQueryParameters(def.surreal.field.default.value)} }`)
+                    .then(([result]) => {
+                    payload.value = result;
+                    // $prefault() does validation on the resolved value
+                    if (def.surreal.field.default?.parse) {
+                        return def.innerType._zod.run(payload, ctx);
+                    }
+                    /**
+                     * $default() returns the default value immediately in forward direction.
+                     * It doesn't pass the default value into the validator ("prefault").
+                     * There's no reason to pass the default value through validation.
+                     * The validity of the default is enforced by TypeScript statically.
+                     * Otherwise, it's the responsibility of the user to ensure the default is valid.
+                     * In the case of pipes with divergent in/out types, you can specify
+                     * the default on the `in` schema of your ZodPipe to set a "prefault" for the pipe.
+                     */
+                    return payload;
+                });
+            }
+            return def.innerType._zod.run(payload, ctx);
+        };
+    }
+    return inst;
+});
+export const _ZodSurrealString = core.$constructor("_ZodSurrealString", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodString.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.string(inst, ctx, json, params);
+    def.surreal.type ??= "string";
+    const bag = inst._zod.bag;
+    inst.format = bag.format ?? null;
+    inst.minLength = bag.minimum ?? null;
+    inst.maxLength = bag.maximum ?? null;
+    // validations
+    inst.regex = (...args) => inst.check(core._regex(...args));
+    inst.includes = (...args) => inst.check(core._includes(...args));
+    inst.startsWith = (...args) => inst.check(core._startsWith(...args));
+    inst.endsWith = (...args) => inst.check(core._endsWith(...args));
+    inst.min = (...args) => inst.check(core._minLength(...args));
+    inst.max = (...args) => inst.check(core._maxLength(...args));
+    inst.length = (...args) => inst.check(core._length(...args));
+    inst.nonempty = (...args) => inst.check(core._minLength(1, ...args));
+    inst.lowercase = (params) => inst.check(core._lowercase(params));
+    inst.uppercase = (params) => inst.check(core._uppercase(params));
+    // transforms
+    inst.trim = () => inst.check(core._trim());
+    inst.normalize = (...args) => inst.check(core._normalize(...args));
+    inst.toLowerCase = () => inst.check(core._toLowerCase());
+    inst.toUpperCase = () => inst.check(core._toUpperCase());
+    inst.slugify = () => inst.check(core._slugify());
+    return inst;
+});
+export const ZodSurrealString = core.$constructor("ZodSurrealString", (inst, def) => {
+    _ZodSurrealString.init(inst, def);
+    inst.email = (params) => inst.check(core._email(ZodSurrealEmail, params));
+    inst.url = (params) => inst.check(url(params));
+    inst.jwt = (params) => inst.check(jwt(params));
+    inst.emoji = (params) => inst.check(emoji(params));
+    inst.guid = (params) => inst.check(guid(params));
+    inst.uuid = (params) => inst.check(uuid(params));
+    inst.uuidv4 = (params) => inst.check(uuidv4(params));
+    inst.uuidv6 = (params) => inst.check(uuidv6(params));
+    inst.uuidv7 = (params) => inst.check(uuidv7(params));
+    inst.nanoid = (params) => inst.check(nanoid(params));
+    inst.guid = (params) => inst.check(guid(params));
+    inst.cuid = (params) => inst.check(cuid(params));
+    inst.cuid2 = (params) => inst.check(cuid2(params));
+    inst.ulid = (params) => inst.check(ulid(params));
+    inst.base64 = (params) => inst.check(base64(params));
+    inst.base64url = (params) => inst.check(base64url(params));
+    inst.xid = (params) => inst.check(xid(params));
+    inst.ksuid = (params) => inst.check(ksuid(params));
+    inst.ipv4 = (params) => inst.check(ipv4(params));
+    inst.ipv6 = (params) => inst.check(ipv6(params));
+    inst.cidrv4 = (params) => inst.check(cidrv4(params));
+    inst.cidrv6 = (params) => inst.check(cidrv6(params));
+    inst.e164 = (params) => inst.check(e164(params));
+    return inst;
+});
+export function string(params) {
+    return new ZodSurrealString({
+        type: "string",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealStringFormat = core.$constructor("ZodSurrealStringFormat", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodStringFormat.init(inst, def);
+    _ZodSurrealString.init(inst, def);
+});
+export const ZodSurrealEmail = core.$constructor("ZodSurrealEmail", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodEmail.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function email(params) {
+    return new ZodSurrealEmail({
+        type: "string",
+        format: "email",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealGUID = core.$constructor("ZodSurrealGUID", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodGUID.init(inst, def);
+    // @ts-expect-error
+    ZodSurrealStringFormat.init(inst, def);
+    const originalParse = inst._zod.parse;
+    inst._zod.parse = (payload, ctx) => {
+        if (payload.value instanceof Uuid) {
+            payload.value = payload.value.toString();
+        }
+        return originalParse(payload, ctx);
+    };
+});
+export function guid(params) {
+    return new ZodSurrealGUID({
+        type: "string",
+        format: "guid",
+        check: "string_format",
+        abort: false,
+        // TODO: Use surreal uuid type instead
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealUUID = core.$constructor("ZodSurrealUUID", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodUUID.init(inst, def);
+    // @ts-expect-error
+    ZodSurrealStringFormat.init(inst, def);
+    const originalParse = inst._zod.parse;
+    inst._zod.parse = (payload, ctx) => {
+        if (payload.value instanceof Uuid) {
+            payload.value = payload.value.toString();
+        }
+        return originalParse(payload, ctx);
+    };
+});
+export function uuid(params) {
+    return new ZodSurrealUUID({
+        type: "string",
+        format: "uuid",
+        check: "string_format",
+        abort: false,
+        // TODO: Use surreal uuid type instead
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export function uuidv4(params) {
+    return new ZodSurrealUUID({
+        type: "string",
+        format: "uuid",
+        check: "string_format",
+        abort: false,
+        version: "v4",
+        // TODO: Use surreal uuid type instead
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+// ZodSurrealUUIDv6
+export function uuidv6(params) {
+    return new ZodSurrealUUID({
+        type: "string",
+        format: "uuid",
+        check: "string_format",
+        abort: false,
+        version: "v6",
+        // TODO: Use surreal uuid type instead
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+// ZodSurrealUUIDv7
+export function uuidv7(params) {
+    return new ZodSurrealUUID({
+        type: "string",
+        format: "uuid",
+        check: "string_format",
+        abort: false,
+        version: "v7",
+        // TODO: Use surreal uuid type instead
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealURL = core.$constructor("ZodSurrealURL", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodURL.init(inst, def);
+    // @ts-expect-error
+    ZodSurrealStringFormat.init(inst, def);
+    const originalParse = inst._zod.parse;
+    inst._zod.parse = (payload, ctx) => {
+        if (payload.value instanceof URL) {
+            payload.value = payload.value.toString();
+        }
+        return originalParse(payload, ctx);
+    };
+});
+export function url(params) {
+    return new ZodSurrealURL({
+        type: "string",
+        format: "url",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealEmoji = core.$constructor("ZodSurrealEmoji", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodEmoji.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function emoji(params) {
+    return new ZodSurrealEmoji({
+        type: "string",
+        format: "emoji",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealNanoID = core.$constructor("ZodSurrealNanoID", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodNanoID.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function nanoid(params) {
+    return new ZodSurrealNanoID({
+        type: "string",
+        format: "nanoid",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealCUID = core.$constructor("ZodSurrealCUID", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodCUID.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function cuid(params) {
+    return new ZodSurrealCUID({
+        type: "string",
+        format: "cuid",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealCUID2 = core.$constructor("ZodSurrealCUID2", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodCUID2.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function cuid2(params) {
+    return new ZodSurrealCUID2({
+        type: "string",
+        format: "cuid2",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealULID = core.$constructor("ZodSurrealULID", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodULID.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function ulid(params) {
+    return new ZodSurrealULID({
+        type: "string",
+        format: "ulid",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealXID = core.$constructor("ZodSurrealXID", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodXID.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function xid(params) {
+    return new ZodSurrealXID({
+        type: "string",
+        format: "xid",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealKSUID = core.$constructor("ZodSurrealKSUID", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodKSUID.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function ksuid(params) {
+    return new ZodSurrealKSUID({
+        type: "string",
+        format: "ksuid",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealIPv4 = core.$constructor("ZodSurrealIPv4", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodIPv4.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function ipv4(params) {
+    return new ZodSurrealIPv4({
+        type: "string",
+        format: "ipv4",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealMAC = core.$constructor("ZodSurrealMAC", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodMAC.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function mac(params) {
+    return new ZodSurrealMAC({
+        type: "string",
+        format: "mac",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealIPv6 = core.$constructor("ZodSurrealIPv6", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodIPv6.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function ipv6(params) {
+    return new ZodSurrealIPv6({
+        type: "string",
+        format: "ipv6",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealCIDRv4 = core.$constructor("ZodSurrealCIDRv4", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodCIDRv4.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function cidrv4(params) {
+    return new ZodSurrealCIDRv4({
+        type: "string",
+        format: "cidrv4",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealCIDRv6 = core.$constructor("ZodSurrealCIDRv6", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodCIDRv6.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function cidrv6(params) {
+    return new ZodSurrealCIDRv6({
+        type: "string",
+        format: "cidrv6",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealBase64 = core.$constructor("ZodSurrealBase64", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodBase64.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function base64(params) {
+    return new ZodSurrealBase64({
+        type: "string",
+        format: "base64",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealBase64URL = core.$constructor("ZodSurrealBase64URL", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodBase64URL.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function base64url(params) {
+    return new ZodSurrealBase64URL({
+        type: "string",
+        format: "base64url",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealE164 = core.$constructor("ZodSurrealE164", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodE164.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function e164(params) {
+    return new ZodSurrealE164({
+        type: "string",
+        format: "e164",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealJWT = core.$constructor("ZodSurrealJWT", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodJWT.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function jwt(params) {
+    return new ZodSurrealJWT({
+        type: "string",
+        format: "jwt",
+        check: "string_format",
+        abort: false,
+        ...core.util.normalizeParams(params),
+        surreal: { type: "string" },
+    });
+}
+export const ZodSurrealCustomStringFormat = core.$constructor("ZodSurrealCustomStringFormat", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodCustomStringFormat.init(inst, def);
+    ZodSurrealStringFormat.init(inst, def);
+});
+export function stringFormat(format, fnOrRegex, _params = {}) {
+    const params = _core_.normalizeParams(_params, { type: "string" });
+    const def = {
+        ..._core_.normalizeParams(_params, { type: "string" }),
+        check: "string_format",
+        type: "string",
+        format,
+        fn: typeof fnOrRegex === "function"
+            ? fnOrRegex
+            : (val) => fnOrRegex.test(val),
+        ...params,
+    };
+    if (fnOrRegex instanceof RegExp) {
+        def.pattern = fnOrRegex;
+    }
+    const inst = new ZodSurrealCustomStringFormat(def);
     return inst;
+}
+export function hostname(_params) {
+    return stringFormat("hostname", core.regexes.hostname, _params);
+}
+export function hex(_params) {
+    return stringFormat("hex", core.regexes.hex, _params);
+}
+export function hash(alg, params) {
+    const enc = params?.enc ?? "hex";
+    const format = `${alg}_${enc}`;
+    const regex = core.regexes[format];
+    if (!regex)
+        throw new Error(`Unrecognized hash format: ${format}`);
+    return stringFormat(format, regex, params);
+}
+export const ZodSurrealNumber = core.$constructor("ZodSurrealNumber", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodNumber.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.number(inst, ctx, json, params);
+    inst.gt = (value, params) => inst.check(core._gt(value, params));
+    inst.gte = (value, params) => inst.check(core._gte(value, params));
+    inst.min = (value, params) => inst.check(core._gte(value, params));
+    inst.lt = (value, params) => inst.check(core._lt(value, params));
+    inst.lte = (value, params) => inst.check(core._lte(value, params));
+    inst.max = (value, params) => inst.check(core._lte(value, params));
+    inst.int = (params) => inst.check(int(params));
+    inst.safe = (params) => inst.check(int(params));
+    inst.positive = (params) => inst.check(core._gt(0, params));
+    inst.nonnegative = (params) => inst.check(core._gte(0, params));
+    inst.negative = (params) => inst.check(core._lt(0, params));
+    inst.nonpositive = (params) => inst.check(core._lte(0, params));
+    inst.multipleOf = (value, params) => inst.check(core._multipleOf(value, params));
+    inst.step = (value, params) => inst.check(core._multipleOf(value, params));
+    // inst.finite = (params) => inst.check(core.finite(params));
+    inst.finite = () => inst;
+    def.surreal.type ??= "number";
+    const bag = inst._zod.bag;
+    inst.minValue =
+        Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+    inst.maxValue =
+        Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+    inst.isInt =
+        (bag.format ?? "").includes("int") ||
+            Number.isSafeInteger(bag.multipleOf ?? 0.5);
+    inst.isFinite = true;
+    inst.format = bag.format ?? null;
+});
+export function number(params) {
+    return new ZodSurrealNumber({
+        type: "number",
+        checks: [],
+        ...core.util.normalizeParams(params),
+        surreal: { type: "number" },
+    });
+}
+export const ZodSurrealNumberFormat = core.$constructor("ZodSurrealNumberFormat", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodNumberFormat.init(inst, def);
+    ZodSurrealNumber.init(inst, def);
+});
+export function int(params) {
+    return new ZodSurrealNumberFormat({
+        type: "number",
+        check: "number_format",
+        abort: false,
+        format: "safeint",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "int" },
+    });
+}
+export function float32(params) {
+    return new ZodSurrealNumberFormat({
+        type: "number",
+        check: "number_format",
+        abort: false,
+        format: "float32",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "float" },
+    });
+}
+export function float64(params) {
+    return new ZodSurrealNumberFormat({
+        type: "number",
+        check: "number_format",
+        abort: false,
+        format: "float64",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "float" },
+    });
+}
+export function int32(params) {
+    return new ZodSurrealNumberFormat({
+        type: "number",
+        check: "number_format",
+        abort: false,
+        format: "int32",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "int" },
+    });
+}
+export function uint32(params) {
+    return new ZodSurrealNumberFormat({
+        type: "number",
+        check: "number_format",
+        abort: false,
+        format: "uint32",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "int" },
+    });
+}
+export const ZodSurrealBoolean = core.$constructor("ZodBoolean", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodBoolean.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.boolean(inst, ctx, json, params);
+    def.surreal.type ??= "bool";
+});
+export function boolean(params) {
+    return new ZodSurrealBoolean({
+        type: "boolean",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "bool" },
+    });
+}
+export const ZodSurrealBigInt = core.$constructor("ZodSurrealBigInt", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodBigInt.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    // @ts-expect-error
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.bigint(inst, ctx, json, params);
+    inst.gte = (value, params) => inst.check(core._gte(value, params));
+    inst.min = (value, params) => inst.check(core._gte(value, params));
+    inst.gt = (value, params) => inst.check(core._gt(value, params));
+    inst.gte = (value, params) => inst.check(core._gte(value, params));
+    inst.min = (value, params) => inst.check(core._gte(value, params));
+    inst.lt = (value, params) => inst.check(core._lt(value, params));
+    inst.lte = (value, params) => inst.check(core._lte(value, params));
+    inst.max = (value, params) => inst.check(core._lte(value, params));
+    inst.positive = (params) => inst.check(core._gt(BigInt(0), params));
+    inst.negative = (params) => inst.check(core._lt(BigInt(0), params));
+    inst.nonpositive = (params) => inst.check(core._lte(BigInt(0), params));
+    inst.nonnegative = (params) => inst.check(core._gte(BigInt(0), params));
+    inst.multipleOf = (value, params) => inst.check(core._multipleOf(value, params));
+    def.surreal.type ??= "int";
+    const bag = inst._zod.bag;
+    inst.minValue = bag.minimum ?? null;
+    inst.maxValue = bag.maximum ?? null;
+    inst.format = bag.format ?? null;
+});
+export function bigint(params) {
+    return new ZodSurrealBigInt({
+        type: "bigint",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "int" },
+    });
+}
+export const ZodSurrealBigIntFormat = core.$constructor("ZodSurrealBigIntFormat", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodBigIntFormat.init(inst, def);
+    ZodSurrealBigInt.init(inst, def);
+});
+// int64
+export function int64(params) {
+    return new ZodSurrealBigIntFormat({
+        type: "bigint",
+        check: "bigint_format",
+        abort: false,
+        format: "int64",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "int" },
+    });
+}
+// uint64
+export function uint64(params) {
+    return new ZodSurrealBigIntFormat({
+        type: "bigint",
+        check: "bigint_format",
+        abort: false,
+        format: "uint64",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "int" },
+    });
+}
+export const ZodSurrealSymbol = core.$constructor("ZodSurrealSymbol", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodSymbol.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.symbol(inst, ctx, json, params);
+});
+export function symbol(params) {
+    return new ZodSurrealSymbol({
+        type: "symbol",
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealUndefined = core.$constructor("ZodSurrealUndefined", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodUndefined.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.undefined(inst, ctx, json, params);
+    def.surreal.type ??= "none";
+});
+function _undefined(params) {
+    return new ZodSurrealUndefined({
+        type: "undefined",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "none" },
+    });
+}
+export { _undefined as undefined };
+export const ZodSurrealNull = core.$constructor("ZodSurrealNull", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodNull.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.null(inst, ctx, json, params);
+    def.surreal.type ??= "null";
+});
+function _null(params) {
+    return new ZodSurrealNull({
+        type: "null",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "null" },
+    });
+}
+export { _null as null };
+export const ZodSurrealAny = core.$constructor("ZodSurrealAny", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodAny.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.any(inst, ctx, json, params);
+    def.surreal.type ??= "any";
+});
+export function any() {
+    return new ZodSurrealAny({
+        type: "any",
+        surreal: { type: "any" },
+    });
+}
+export const ZodSurrealUnknown = core.$constructor("ZodSurrealUnknown", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodUnknown.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.unknown(inst, ctx, json, params);
+    def.surreal.type ??= "any";
+});
+export function unknown() {
+    return new ZodSurrealUnknown({
+        type: "unknown",
+        surreal: { type: "any" },
+    });
+}
+export const ZodSurrealNever = core.$constructor("ZodSurrealNever", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodNever.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.never(inst, ctx, json, params);
+    def.surreal.type = "none";
+});
+export function never(params) {
+    return new ZodSurrealNever({
+        type: "never",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "none" },
+    });
+}
+export const ZodSurrealVoid = core.$constructor("ZodSurrealVoid", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodVoid.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.void(inst, ctx, json, params);
+    def.surreal.type ??= "none";
+});
+function _void(params) {
+    return new ZodSurrealVoid({
+        type: "void",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "none" },
+    });
+}
+export { _void as void };
+export const ZodSurrealDate = core.$constructor("ZodSurrealDate", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodDate.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    // @ts-expect-error
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.date(inst, ctx, json, params);
+    inst.min = (value, params) => inst.check(core._gte(value instanceof DateTime ? value.toDate() : value, params));
+    inst.max = (value, params) => inst.check(core._lte(value instanceof DateTime ? value.toDate() : value, params));
+    def.surreal.type ??= "datetime";
+    const c = inst._zod.bag;
+    inst.minDate = c.minimum ? new Date(c.minimum) : null;
+    inst.maxDate = c.maximum ? new Date(c.maximum) : null;
+    const originalParse = inst._zod.parse;
+    inst._zod.parse = (payload, ctx) => {
+        if (payload.value instanceof DateTime) {
+            payload.value = payload.value.toDate();
+        }
+        return originalParse(payload, ctx);
+    };
+});
+function _date(params) {
+    return new ZodSurrealDate({
+        type: "date",
+        ...core.util.normalizeParams(params),
+        surreal: { type: "datetime" },
+    });
+}
+export { _date as date };
+export const ZodSurrealArray = core.$constructor("ZodSurrealArray", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodArray.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.array(inst, ctx, json, params);
+    inst.element = def.element;
+    inst.min = (minLength, params) => inst.check(core._minLength(minLength, params));
+    inst.nonempty = (params) => inst.check(core._minLength(1, params));
+    inst.max = (maxLength, params) => inst.check(core._maxLength(maxLength, params));
+    inst.length = (len, params) => inst.check(core._length(len, params));
+    inst.unwrap = () => inst.element;
+});
+export function array(element, params) {
+    return new ZodSurrealArray({
+        type: "array",
+        element,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+// .keyof
+export function keyof(schema) {
+    const shape = schema._zod.def.shape;
+    return _enum(Object.keys(shape));
+}
+export const ZodSurrealObject = core.$constructor("ZodSurrealObject", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodObjectJIT.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.object(inst, ctx, json, params);
+    core.util.defineLazy(inst, "shape", () => {
+        return def.shape;
+    });
+    inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
+    inst.catchall = (catchall) => inst.clone({
+        ...inst._zod.def,
+        catchall: catchall,
+    });
+    inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
+    inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
+    inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
+    inst.strip = () => inst.clone({ ...inst._zod.def, catchall: undefined });
+    inst.extend = (incoming) => {
+        return core.util.extend(inst, incoming);
+    };
+    inst.safeExtend = (incoming) => {
+        return core.util.safeExtend(inst, incoming);
+    };
+    inst.merge = (other) => core.util.merge(inst, other);
+    inst.pick = (mask) => core.util.pick(inst, mask);
+    inst.omit = (mask) => core.util.omit(inst, mask);
+    inst.partial = (...args) => core.util.partial(ZodSurrealOptional, inst, args[0]);
+    inst.required = (...args) => core.util.required(ZodSurrealNonOptional, inst, args[0]);
+});
+export function object(shape, params) {
+    const def = {
+        type: "object",
+        shape: shape ?? {},
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    };
+    return new ZodSurrealObject(def);
+}
+// strictObject
+export function strictObject(shape, params) {
+    return new ZodSurrealObject({
+        type: "object",
+        shape,
+        catchall: never(),
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+// looseObject
+export function looseObject(shape, params) {
+    return new ZodSurrealObject({
+        type: "object",
+        shape,
+        catchall: unknown(),
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealUnion = core.$constructor("ZodSurrealUnion", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodUnion.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.union(inst, ctx, json, params);
+    inst.options = def.options;
+});
+export function union(options, params) {
+    return new ZodSurrealUnion({
+        type: "union",
+        options: options,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealXor = 
+/*@__PURE__*/ core.$constructor("ZodSurrealXor", (inst, def) => {
+    ZodSurrealUnion.init(inst, def);
+    // @ts-expect-error
+    core.$ZodXor.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.union(inst, ctx, json, params);
+    inst.options = def.options;
+});
+/** Creates an exclusive union (XOR) where exactly one option must match.
+ * Unlike regular unions that succeed when any option matches, xor fails if
+ * zero or more than one option matches the input. */
+export function xor(options, params) {
+    return new ZodSurrealXor({
+        type: "union",
+        options: options,
+        inclusive: false,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealDiscriminatedUnion = core.$constructor("ZodSurrealDiscriminatedUnion", (inst, def) => {
+    ZodSurrealUnion.init(inst, def);
+    // @ts-expect-error
+    core.$ZodDiscriminatedUnion.init(inst, def);
+});
+export function discriminatedUnion(discriminator, options, params) {
+    // const [options, params] = args;
+    return new ZodSurrealDiscriminatedUnion({
+        type: "union",
+        options,
+        discriminator,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodIntersection = 
+/*@__PURE__*/ core.$constructor("ZodIntersection", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodIntersection.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.intersection(inst, ctx, json, params);
+});
+export function intersection(left, right) {
+    return new ZodIntersection({
+        type: "intersection",
+        left: left,
+        right: right,
+        surreal: {},
+    });
+}
+export const ZodSurrealTuple = core.$constructor("ZodSurrealTuple", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodTuple.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.tuple(inst, ctx, json, params);
+    inst.rest = (rest) => inst.clone({
+        ...inst._zod.def,
+        rest: rest,
+    });
+});
+export function tuple(items, _paramsOrRest, _params) {
+    const hasRest = _paramsOrRest instanceof ZodSurrealType;
+    const params = hasRest ? _params : _paramsOrRest;
+    const rest = hasRest ? _paramsOrRest : null;
+    return new ZodSurrealTuple({
+        type: "tuple",
+        items: items,
+        rest,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealRecord = core.$constructor("ZodSurrealRecord", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodRecord.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.record(inst, ctx, json, params);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+});
+export function record(keyType, valueType, params) {
+    return new ZodSurrealRecord({
+        type: "record",
+        keyType,
+        valueType: valueType,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export function partialRecord(keyType, valueType, params) {
+    const k = core.clone(keyType);
+    k._zod.values = undefined;
+    return new ZodSurrealRecord({
+        type: "record",
+        keyType: k,
+        valueType: valueType,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export function looseRecord(keyType, valueType, params) {
+    return new ZodSurrealRecord({
+        type: "record",
+        keyType,
+        valueType: valueType,
+        mode: "loose",
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealMap = core.$constructor("ZodSurrealMap", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodMap.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.map(inst, ctx, json, params);
+    inst.keyType = def.keyType;
+    inst.valueType = def.valueType;
+    inst.min = (...args) => inst.check(core._minSize(...args));
+    inst.nonempty = (params) => inst.check(core._minSize(1, params));
+    inst.max = (...args) => inst.check(core._maxSize(...args));
+    inst.size = (...args) => inst.check(core._size(...args));
+});
+export function map(keyType, valueType, params) {
+    return new ZodSurrealMap({
+        type: "map",
+        keyType: keyType,
+        valueType: valueType,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealSet = core.$constructor("ZodSurrealSet", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodSet.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.set(inst, ctx, json, params);
+    inst.min = (...args) => inst.check(core._minSize(...args));
+    inst.nonempty = (params) => inst.check(core._minSize(1, params));
+    inst.max = (...args) => inst.check(core._maxSize(...args));
+    inst.size = (...args) => inst.check(core._size(...args));
+});
+export function set(valueType, params) {
+    return new ZodSurrealSet({
+        type: "set",
+        valueType: valueType,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealEnum = 
+/*@__PURE__*/ core.$constructor("ZodEnum", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodEnum.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.enum(inst, ctx, json, params);
+    inst.enum = def.entries;
+    inst.options = Object.values(def.entries);
+    const keys = new Set(Object.keys(def.entries));
+    inst.extract = (values, params) => {
+        const newEntries = {};
+        for (const value of values) {
+            if (keys.has(value)) {
+                newEntries[value] = def.entries[value];
+            }
+            else
+                throw new Error(`Key ${value} not found in enum`);
+        }
+        return new ZodSurrealEnum({
+            ...def,
+            checks: [],
+            ...core.util.normalizeParams(params),
+            entries: newEntries,
+        });
+    };
+    inst.exclude = (values, params) => {
+        const newEntries = { ...def.entries };
+        for (const value of values) {
+            if (keys.has(value)) {
+                delete newEntries[value];
+            }
+            else
+                throw new Error(`Key ${value} not found in enum`);
+        }
+        return new ZodSurrealEnum({
+            ...def,
+            checks: [],
+            ...core.util.normalizeParams(params),
+            entries: newEntries,
+        });
+    };
+});
+function _enum(values, params) {
+    const entries = Array.isArray(values)
+        ? Object.fromEntries(values.map((v) => [v, v]))
+        : values;
+    return new ZodSurrealEnum({
+        type: "enum",
+        entries,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export { _enum as enum };
+/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
+ *
+ * ```ts
+ * enum Colors { red, green, blue }
+ * z.enum(Colors);
+ * ```
+ */
+export function nativeEnum(entries, params) {
+    return new ZodSurrealEnum({
+        type: "enum",
+        entries,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealLiteral = core.$constructor("ZodSurrealLiteral", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodLiteral.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.literal(inst, ctx, json, params);
+    inst.values = new Set(def.values);
+    Object.defineProperty(inst, "value", {
+        get() {
+            if (def.values.length > 1) {
+                throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+            }
+            return def.values[0];
+        },
+    });
+});
+export function literal(value, params) {
+    return new ZodSurrealLiteral({
+        type: "literal",
+        values: Array.isArray(value) ? value : [value],
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealFile = core.$constructor("ZodSurrealFile", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodFile.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.file(inst, ctx, json, params);
+    inst.min = (size, params) => inst.check(core._minSize(size, params));
+    inst.max = (size, params) => inst.check(core._maxSize(size, params));
+    inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));
+});
+export function file(params) {
+    return new ZodSurrealFile({
+        type: "file",
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
+}
+export const ZodSurrealTransform = core.$constructor("ZodSurrealTransform", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodTransform.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.transform(inst, ctx, json, params);
+    inst._zod.parse = (payload, _ctx) => {
+        if (_ctx.direction === "backward") {
+            throw new core.$ZodEncodeError(inst.constructor.name);
+        }
+        payload.addIssue = (issue) => {
+            if (typeof issue === "string") {
+                payload.issues.push(core.util.issue(issue, payload.value, def));
+            }
+            else {
+                // for Zod 3 backwards compatibility
+                const _issue = issue;
+                if (_issue.fatal)
+                    _issue.continue = false;
+                _issue.code ??= "custom";
+                _issue.input ??= payload.value;
+                _issue.inst ??= inst;
+                // _issue.continue ??= true;
+                payload.issues.push(core.util.issue(_issue));
+            }
+        };
+        const output = def.transform(payload.value, payload);
+        if (output instanceof Promise) {
+            return output.then((output) => {
+                payload.value = output;
+                return payload;
+            });
+        }
+        payload.value = output;
+        return payload;
+    };
+});
+export function transform(fn) {
+    return new ZodSurrealTransform({
+        type: "transform",
+        transform: fn,
+        surreal: {},
+    });
+}
+export const ZodSurrealOptional = core.$constructor("ZodSurrealOptional", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodOptional.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.optional(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+});
+export function optional(innerType) {
+    return new ZodSurrealOptional({
+        type: "optional",
+        innerType: innerType,
+        surreal: {},
+    });
+}
+export const ZodSurrealExactOptional = core.$constructor("ZodSurrealExactOptional", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodExactOptional.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.optional(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
 });
-export const SurrealZodAny = core.$constructor("SurrealZodAny", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodAny.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "any";
+export function exactOptional(innerType) {
+    return new ZodSurrealExactOptional({
+        type: "optional",
+        innerType: innerType,
+        surreal: {},
+    });
+}
+export const ZodSurrealNullable = 
+/*@__PURE__*/ core.$constructor("ZodSurrealNullable", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodNullable.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.nullable(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
 });
-export function any() {
-    return core._any(SurrealZodAny);
+export function nullable(innerType) {
+    return new ZodSurrealNullable({
+        type: "nullable",
+        innerType: innerType,
+        surreal: {},
+    });
 }
-export const SurrealZodUnknown = core.$constructor("SurrealZodUnknown", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodUnknown.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "unknown";
+// nullish
+export function nullish(innerType) {
+    return optional(nullable(innerType));
+}
+export const ZodSurrealDefault = core.$constructor("ZodSurrealDefault", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodDefault.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.default(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+    inst.removeDefault = inst.unwrap;
 });
-export function unknown() {
-    return core._unknown(SurrealZodUnknown);
+export function _default(innerType, defaultValue) {
+    return new ZodSurrealDefault({
+        type: "default",
+        innerType: innerType,
+        get defaultValue() {
+            return typeof defaultValue === "function"
+                ? defaultValue()
+                : core.util.shallowClone(defaultValue);
+        },
+        surreal: {},
+    });
 }
-export const SurrealZodNever = core.$constructor("SurrealZodNever", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodNever.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "never";
+export const ZodSurrealPrefault = core.$constructor("ZodSurrealPrefault", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodPrefault.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.prefault(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
 });
-export function never(params) {
-    return core._never(SurrealZodNever, params);
+export function prefault(innerType, defaultValue) {
+    return new ZodSurrealPrefault({
+        type: "prefault",
+        innerType: innerType,
+        get defaultValue() {
+            return typeof defaultValue === "function"
+                ? defaultValue()
+                : core.util.shallowClone(defaultValue);
+        },
+        surreal: {},
+    });
 }
-export const SurrealZodUndefined = core.$constructor("SurrealZodUndefined", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodUndefined.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "undefined";
+export const ZodSurrealNonOptional = core.$constructor("ZodSurrealNonOptional", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodNonOptional.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.nonoptional(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
 });
-function _undefined(params) {
-    return core._undefined(SurrealZodUndefined, params);
+export function nonoptional(innerType, params) {
+    return new ZodSurrealNonOptional({
+        type: "nonoptional",
+        innerType: innerType,
+        ...core.util.normalizeParams(params),
+        surreal: {},
+    });
 }
-export { _undefined as undefined };
-export const SurrealZodNull = core.$constructor("SurrealZodNull", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodNull.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "null";
+export const ZodSurrealSuccess = core.$constructor("ZodSuccess", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodSuccess.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.success(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
 });
-function _null(params) {
-    return core._null(SurrealZodNull, params);
+export function success(innerType) {
+    return new ZodSurrealSuccess({
+        type: "success",
+        innerType: innerType,
+        surreal: {},
+    });
 }
-export { _null as null };
-export const SurrealZodBoolean = core.$constructor("SurrealZodBoolean", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodBoolean.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "boolean";
+export const ZodSurrealCatch = core.$constructor("ZodSurrealCatch", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodCatch.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.catch(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+    inst.removeCatch = inst.unwrap;
 });
-export function boolean(params) {
-    return core._boolean(SurrealZodBoolean, params);
+function _catch(innerType, catchValue) {
+    return new ZodSurrealCatch({
+        type: "catch",
+        innerType: innerType,
+        catchValue: (typeof catchValue === "function"
+            ? catchValue
+            : () => catchValue),
+        surreal: {},
+    });
 }
-export const SurrealZodString = core.$constructor("SurrealZodString", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodString.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "string";
+export { _catch as catch };
+export const ZodSurrealNaN = core.$constructor("ZodSurrealNaN", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodNaN.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.nan(inst, ctx, json, params);
 });
-export function string(params) {
-    return core._string(SurrealZodString, params);
+export function nan(params) {
+    return new ZodSurrealNaN({
+        type: "nan",
+        ...core.util.normalizeParams(params),
+        surreal: {
+            type: "number",
+        },
+    });
 }
-export const SurrealZodNumber = core.$constructor("SurrealZodNumber", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodNumber.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "number";
+export const ZodSurrealPipe = core.$constructor("ZodSurrealPipe", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodPipe.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.pipe(inst, ctx, json, params);
+    inst.in = def.in;
+    inst.out = def.out;
 });
-export function number(params) {
-    return core._number(SurrealZodNumber, params);
+export function pipe(in_, out) {
+    return new ZodSurrealPipe({
+        type: "pipe",
+        in: in_,
+        out: out,
+        // ...util.normalizeParams(params),
+        surreal: {},
+    });
 }
-export const SurrealZodBigInt = core.$constructor("SurrealZodBigInt", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodBigInt.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "bigint";
+export const ZodSurrealCodec = core.$constructor("ZodSurrealCodec", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodCodec.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
 });
-export function bigint(params) {
-    return core._bigint(SurrealZodBigInt, params);
+export function codec(in_, out, params) {
+    return new ZodSurrealCodec({
+        type: "pipe",
+        in: in_,
+        out: out,
+        transform: params.decode,
+        reverseTransform: params.encode,
+        surreal: {},
+    });
 }
-export const SurrealZodObject = core.$constructor("SurrealZodObject", (inst, def) => {
-    // TODO: Inline implementation and use core instead
-    // @ts-expect-error - unknown assertion error
-    core.$ZodObject.init(inst, def);
-    SurrealZodType.init(inst, def);
-    // surreal internals
-    inst._zod.def.surreal.type = "object";
-    // inst._zod.def.surreal.flexible = false;
-    inst.loose = () => inst.clone({
-        ...def,
-        catchall: unknown(),
+export const ZodSurrealReadonly = core.$constructor("ZodSurrealReadonly", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodReadonly.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.readonly(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+});
+export function readonly(innerType) {
+    return new ZodSurrealReadonly({
+        type: "readonly",
+        innerType: innerType,
+        surreal: {},
     });
-    inst.flexible = inst.loose;
-    inst.strict = () => inst.clone({
-        ...def,
-        catchall: never(),
+}
+export const ZodSurrealTemplateLiteral = core.$constructor("ZodSurrealTemplateLiteral", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodTemplateLiteral.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.template_literal(inst, ctx, json, params);
+});
+export function templateLiteral(parts, params) {
+    return new ZodSurrealTemplateLiteral({
+        type: "template_literal",
+        parts,
+        ...core.util.normalizeParams(params),
+        surreal: {},
     });
-    inst.extend = (incoming) => core.util.extend(inst, incoming);
-    inst.safeExtend = (incoming) => core.util.safeExtend(inst, incoming);
+}
+export const ZodSurrealLazy = core.$constructor("ZodSurrealLazy", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodLazy.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.lazy(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.getter();
 });
-export function object(shape, params) {
-    const def = {
-        type: "object",
-        shape: shape ?? {},
+export function lazy(getter) {
+    return new ZodSurrealLazy({
+        type: "lazy",
+        getter: getter,
+        surreal: {},
+    });
+}
+export const ZodSurrealPromise = core.$constructor("ZodSurrealPromise", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodPromise.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.promise(inst, ctx, json, params);
+    inst.unwrap = () => inst._zod.def.innerType;
+});
+export function promise(innerType) {
+    return new ZodSurrealPromise({
+        type: "promise",
+        innerType: innerType,
+        surreal: {},
+    });
+}
+export const ZodSurrealFunction = core.$constructor("ZodSurrealFunction", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodFunction.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    // @ts-expect-error
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => 
+    // @ts-expect-error
+    allProcessors.function(inst, ctx, json, params);
+});
+export function _function(params) {
+    return new ZodSurrealFunction({
+        type: "function",
+        input: Array.isArray(params?.input)
+            ? tuple(params?.input)
+            : (params?.input ?? array(unknown())),
+        output: params?.output ?? unknown(),
+        surreal: {},
+    });
+}
+export { _function as function };
+export const ZodSurrealCustom = core.$constructor("ZodSurrealCustom", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodCustom.init(inst, def);
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => allProcessors.custom(inst, ctx, json, params);
+});
+// custom checks
+export function check(fn) {
+    const ch = new core.$ZodCheck({
+        check: "custom",
+        // ...util.normalizeParams(params),
+    });
+    ch._zod.check = fn;
+    return ch;
+}
+export function custom(fn, _params) {
+    const norm = core.util.normalizeParams(_params);
+    norm.abort ??= true; // default to abort:false
+    const schema = new ZodSurrealCustom({
+        type: "custom",
+        check: "custom",
+        fn: fn ?? (() => true),
+        ...norm,
+        surreal: {},
+    });
+    return schema;
+}
+export function refine(fn, _params = {}) {
+    const schema = new ZodSurrealCustom({
+        type: "custom",
+        check: "custom",
+        fn: fn,
+        ...core.util.normalizeParams(_params),
+        surreal: {},
+    });
+    return schema;
+}
+// superRefine
+export function superRefine(fn) {
+    const ch = core._check((payload) => {
+        payload.addIssue = (issue) => {
+            if (typeof issue === "string") {
+                payload.issues.push(core.util.issue(issue, payload.value, ch._zod.def));
+            }
+            else {
+                // for Zod 3 backwards compatibility
+                const _issue = issue;
+                if (_issue.fatal)
+                    _issue.continue = false;
+                _issue.code ??= "custom";
+                _issue.input ??= payload.value;
+                _issue.inst ??= ch;
+                _issue.continue ??= !ch._zod.def.abort; // abort is always undefined, so this is always true...
+                payload.issues.push(core.util.issue(_issue));
+            }
+        };
+        return fn(payload.value, payload);
+    });
+    return ch;
+}
+// Re-export describe and meta from core
+export const describe = core.describe;
+export const meta = core.meta;
+function _instanceof(cls, params = {}) {
+    const inst = new ZodSurrealCustom({
+        type: "custom",
+        check: "custom",
+        fn: (data) => data instanceof cls,
+        abort: true,
         ...core.util.normalizeParams(params),
-    };
-    return new SurrealZodObject({
-        ...def,
         surreal: {
-            type: "object",
-            flexible: false,
+            type: "custom",
         },
     });
+    inst._zod.bag.Class = cls;
+    // Override check to emit invalid_type instead of custom
+    inst._zod.check = (payload) => {
+        if (!(payload.value instanceof cls)) {
+            payload.issues.push({
+                code: "invalid_type",
+                expected: cls.name,
+                input: payload.value,
+                inst,
+                path: [...(inst._zod.def.path ?? [])],
+            });
+        }
+    };
+    return inst;
+}
+export { _instanceof as instanceof };
+// stringbool
+export const stringbool = (_params) => {
+    const params = core.util.normalizeParams(_params);
+    let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
+    let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
+    if (params.case !== "sensitive") {
+        truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
+        falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
+    }
+    const truthySet = new Set(truthyArray);
+    const falsySet = new Set(falsyArray);
+    const stringSchema = new ZodSurrealString({
+        type: "string",
+        error: params.error,
+        surreal: { type: "string" },
+    });
+    const booleanSchema = new ZodSurrealBoolean({
+        type: "boolean",
+        error: params.error,
+        surreal: { type: "bool" },
+    });
+    const codec = new ZodSurrealCodec({
+        type: "pipe",
+        in: stringSchema,
+        out: booleanSchema,
+        transform: ((input, payload) => {
+            let data = input;
+            if (params.case !== "sensitive")
+                data = data.toLowerCase();
+            if (truthySet.has(data)) {
+                return true;
+            }
+            else if (falsySet.has(data)) {
+                return false;
+            }
+            else {
+                payload.issues.push({
+                    code: "invalid_value",
+                    expected: "stringbool",
+                    values: [...truthySet, ...falsySet],
+                    input: payload.value,
+                    inst: codec,
+                    continue: false,
+                });
+                return {};
+            }
+        }),
+        reverseTransform: ((input, _payload) => {
+            if (input === true) {
+                return truthyArray[0] || "true";
+            }
+            else {
+                return falsyArray[0] || "false";
+            }
+        }),
+        error: params.error,
+        surreal: {},
+    });
+    return codec;
+};
+export function json(params) {
+    const jsonSchema = lazy(() => {
+        return union([
+            string(params),
+            number(),
+            boolean(),
+            _null(),
+            array(jsonSchema),
+            record(string(), jsonSchema),
+        ]);
+    });
+    return jsonSchema;
+}
+////////////////////////////////////////////////////
+////////////////////////////////////////////////////
+//////////                                //////////
+//////////      ZodSurrealPreprocess      //////////
+//////////                                //////////
+////////////////////////////////////////////////////
+////////////////////////////////////////////////////
+// /** @deprecated Use `z.pipe()` and `z.transform()` instead. */
+export function preprocess(fn, schema) {
+    return pipe(transform(fn), schema);
 }
 function normalizeRecordIdDef(def) {
-    const invalidType = getInvalidRecordIdValueSchema(def.innerType);
-    if (invalidType) {
-        throw new Error(`${invalidType} is not valid as a RecordId's value`);
+    const { type, context } = inferSurrealType(def.innerType);
+    const isValid = Array.from(context.type).every((option) => ["any", "string", "number", "int", "array", "object"].includes(option) ||
+        option.startsWith("array<") ||
+        option.startsWith("[") ||
+        option.startsWith("{") ||
+        option.startsWith("'") ||
+        option.startsWith('"') ||
+        /^\d+(\.\d+)?f?$/.test(option));
+    if (!isValid) {
+        throw new Error(`${type} is not valid as a RecordId's value`);
     }
     return {
         ...def,
     };
 }
-function getInvalidRecordIdValueSchema(schema) {
-    const def = schema._zod.def;
-    switch (def.type) {
-        case "any":
-        case "string":
-        case "number":
-            return "";
-        default:
-            return def.type;
-    }
-}
-export const SurrealZodRecordId = core.$constructor("SurrealZodRecordId", (inst, def) => {
-    SurrealZodType.init(inst, def);
+// /* instanbul ignore next */
+// function parseRecordIdString(id: string) {
+//   let table = "";
+//   let value: RecordIdValue = "";
+//   const match = id.match(/^(?:⟨(.*)⟩|`(.*)`|(.*)):(?:⟨(.*)⟩|`(.*)`|(.*))$/);
+//   if (!match) {
+//     throw new Error(`Invalid record id string: ${id}`);
+//   }
+//   table = (match[1] ?? match[2] ?? match[2] ?? "").replace(/\\⟩/g, "⟩");
+//   value = match[4] ?? match[5] ?? match[6] ?? "";
+//   // check if value is a number
+//   value = parseSurrealValue(value);
+//   // console.log("result:", value);
+//   return new RecordId(table, value);
+// }
+// /* instanbul ignore stop */
+// type ParserContext = {
+//   in: "root" | "array" | "object";
+//   acc: string;
+//   path: ("array" | "object")[];
+// };
+// function parseSurrealValue(str: string) {
+//   const stack: {
+//     in: "root" | "array" | "object";
+//     value: any;
+//   }[] = [];
+//   let ctx: ParserContext = {
+//     in: "root",
+//     acc: "",
+//     path: [],
+//   };
+//   let value: any;
+//   function expr() {
+//     const parsed = ctx.acc;
+//     // Decimal with optional exponent
+//     if (/^[-+]?\d+(?:\.\d+)?(?:e[-+]?\d+)?dec$/i.test(parsed)) {
+//       return new Decimal(parsed.slice(0, -3));
+//     }
+//     // Strict integer → Number | BigInt
+//     if (/^[-+]?\d+f?$/.test(parsed)) {
+//       const asBigInt = BigInt(parsed.replace(/f$/i, ""));
+//       if (
+//         asBigInt > BigInt(Number.MAX_SAFE_INTEGER) ||
+//         asBigInt < BigInt(Number.MIN_SAFE_INTEGER)
+//       ) {
+//         return asBigInt;
+//       }
+//       return Number(parsed.replace(/f$/i, ""));
+//     }
+//     // Float or exponent → Number
+//     if (/^[-+]?\d+(?:\.\d+)?(?:e[-+]?\d+)?f?$/i.test(parsed)) {
+//       return Number(parsed.replace(/f$/, ""));
+//     }
+//     return parsed;
+//   }
+//   function enter(type: "array" | "object") {
+//     if (ctx.in !== "root") {
+//       stack.push({ in: ctx.in, value });
+//     }
+//     ctx.in = type;
+//     if (type === "array") {
+//       value = [];
+//     } else if (type === "object") {
+//       value = {};
+//     }
+//   }
+//   function exit() {
+//     if (ctx.in === "array" && ctx.acc) {
+//       nextArray();
+//     }
+//     const popped = stack.pop();
+//     if (!popped) {
+//       return;
+//     }
+//     value = popped.value;
+//     ctx.in = popped.in;
+//     ctx.acc = "";
+//   }
+//   function nextArray() {
+//     (value as any[]).push(expr());
+//   }
+//   for (let i = 0; i < str.length; i++) {
+//     const ch = str[i];
+//     if (ch === "[") {
+//       enter("array");
+//     } else if (ch === "{") {
+//       enter("object");
+//     } else if (ch === "]") {
+//       exit();
+//     } else if (ch === "}") {
+//       exit();
+//     } else if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") {
+//       continue;
+//     } else if (ch === ",") {
+//       if (ctx.in === "array") nextArray();
+//       ctx.acc = "";
+//     } else {
+//       ctx.acc += ch;
+//     }
+//     // console.log(inspect({ ...ctx, stack }, { depth: Infinity, colors: true }));
+//   }
+//   return value;
+// }
+export const ZodSurrealdRecordId = core.$constructor("ZodSurrealRecordId", (inst, def) => {
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
     // surreal internals
-    inst._zod.def.surreal.type = "record_id";
     const normalized = normalizeRecordIdDef(def);
     inst.anytable = () => {
         return inst.clone({
@@ -194,6 +2028,20 @@ export const SurrealZodRecordId = core.$constructor("SurrealZodRecordId", (inst,
             innerType,
         });
     };
+    inst.id = inst.type;
+    inst.value = inst.type;
+    // ------- Parsing/Encoding/Decoding -------
+    const _inst = inst;
+    _inst.fromParts = (table, id, params) => _inst.decode(new RecordId(table, id), params);
+    _inst.fromPartsAsync = (table, id, params) => _inst.decodeAsync(new RecordId(table, id), params);
+    _inst.safeFromParts = (table, id, params) => _inst.safeDecode(new RecordId(table, id), params);
+    _inst.safeFromPartsAsync = (table, id, params) => _inst.safeDecodeAsync(new RecordId(table, id), params);
+    if (normalized.table?.length === 1) {
+        _inst.fromId = (id, params) => _inst.decode(new RecordId(normalized.table?.[0] ?? "", id), params);
+        _inst.fromIdAsync = (id, params) => _inst.decodeAsync(new RecordId(normalized.table?.[0] ?? "", id), params);
+        _inst.safeFromId = (id, params) => _inst.safeDecode(new RecordId(normalized.table?.[0] ?? "", id), params);
+        _inst.safeFromIdAsync = (id, params) => _inst.safeDecodeAsync(new RecordId(normalized.table?.[0] ?? "", id), params);
+    }
     inst._zod.parse = (payload, ctx) => {
         if (payload.value instanceof RecordId) {
             if (normalized.table &&
@@ -221,13 +2069,14 @@ export const SurrealZodRecordId = core.$constructor("SurrealZodRecordId", (inst,
             else if (result.issues.length) {
                 payload.issues.push(...core.util.prefixIssues("id", result.issues));
             }
-            payload.value = new RecordId(payload.value.table.name, result.value);
+            else {
+                payload.value = new RecordId(payload.value.table.name, result.value);
+            }
         }
         else {
             payload.issues.push({
                 code: "invalid_type",
-                // TODO: Surreal specific issues
-                expected: "custom",
+                expected: "record_id",
                 input: payload.value,
             });
         }
@@ -236,14 +2085,11 @@ export const SurrealZodRecordId = core.$constructor("SurrealZodRecordId", (inst,
     return inst;
 });
 export function recordId(what, innerType) {
-    return new SurrealZodRecordId({
-        // Zod would not be happy if we have a custom type here, so we use any
+    return new ZodSurrealdRecordId({
         type: "any",
         table: what ? (Array.isArray(what) ? what : [what]) : undefined,
         innerType: innerType ?? any(),
-        surreal: {
-            type: "record_id",
-        },
+        surreal: {},
     });
 }
 function handleFieldResult(result, final, field, input) {
@@ -252,12 +2098,12 @@ function handleFieldResult(result, final, field, input) {
     }
     if (result.value === undefined) {
         if (field in input) {
-            // @ts-expect-error: field not index-checked on final.value
+            // @ts-expect-error: field not index-checked on final.value, doesnt matter
             final.value[field] = undefined;
         }
     }
     else {
-        // @ts-expect-error: field not index-checked on final.value
+        // @ts-expect-error: field not index-checked on final.value, doesnt matter
         final.value[field] = result.value;
     }
 }
@@ -286,7 +2132,6 @@ function handleCatchall(promises, input, payload, ctx, def, inst) {
             code: "unrecognized_keys",
             keys: unrecognized,
             input,
-            inst,
         });
     }
     if (!promises.length)
@@ -296,29 +2141,19 @@ function handleCatchall(promises, input, payload, ctx, def, inst) {
 function normalizeTableDef(def) {
     const fields = {};
     const fieldNames = Object.keys(def.fields);
-    if (def.fields.id) {
-        if (def.fields.id instanceof SurrealZodRecordId) {
-            fields.id = def.fields.id.table(def.name);
-        }
-        else {
-            fields.id = recordId(def.name).type(def.fields.id);
-        }
-    }
-    else {
+    if (!def.fields.id) {
         fields.id = recordId(def.name).type(any());
         fieldNames.push("id");
     }
-    if (def.dto && !(fields.id instanceof SurrealZodOptional)) {
-        fields.id = optional(fields.id);
+    else if (def.fields.id instanceof ZodSurrealdRecordId) {
+        fields.id = def.fields.id.table(def.name);
+    }
+    else {
+        fields.id = recordId(def.name).type(def.fields.id);
     }
     for (const field of fieldNames) {
         if (field === "id")
             continue;
-        // if (!def.fields[field]?._zod.traits.has("SurrealZodType")) {
-        //   throw new Error(
-        //     `Invalid field definition for "${field}": expected a Surreal Zod schema`,
-        //   );
-        // }
         fields[field] = def.fields[field];
     }
     return {
@@ -328,12 +2163,20 @@ function normalizeTableDef(def) {
         fieldNamesSet: new Set(fieldNames),
     };
 }
-export const SurrealZodTable = core.$constructor("SurrealZodTable", (inst, def) => {
-    SurrealZodType.init(inst, def);
+export const ZodSurrealTable = core.$constructor("SurrealZodTable", (inst, def) => {
+    // @ts-expect-error
+    core.$ZodType.init(inst, def);
     const normalized = normalizeTableDef(def);
     // @ts-expect-error - through normalization id is always present
     inst._zod.def.fields = normalized.fields;
     const catchall = normalized.catchall;
+    const table = new Table(def.name);
+    assignParsingMethods(inst);
+    inst.clone = (def, params) => core.clone(inst, def, params);
+    inst.register = ((reg, meta) => {
+        reg.add(inst, meta);
+        return inst;
+    });
     inst.name = (name) => {
         return inst.clone({
             ...inst._zod.def,
@@ -341,12 +2184,49 @@ export const SurrealZodTable = core.$constructor("SurrealZodTable", (inst, def)
         });
     };
     inst.fields = (fields) => {
+        if (inst._zod.def.surreal.tableType === "relation") {
+            fields = {
+                in: inst._zod.def.fields.in ?? recordId().type(any()),
+                out: inst._zod.def.fields.out ?? recordId().type(any()),
+                ...fields,
+            };
+        }
         return inst.clone({
             ...inst._zod.def,
             // @ts-expect-error - id may or may not be provided
             fields,
         });
     };
+    // @ts-expect-error - type defined conditionally
+    inst.from = (from) => {
+        if (inst._zod.def.surreal.tableType !== "relation") {
+            throw new Error("Cannot call .from() on a non-relation table");
+        }
+        return inst.clone({
+            ...inst._zod.def,
+            fields: {
+                ...inst._zod.def.fields,
+                in: from instanceof ZodSurrealdRecordId ? from : recordId(from),
+            },
+        });
+    };
+    // @ts-expect-error - type defined conditionally
+    inst.to = (to) => {
+        if (inst._zod.def.surreal.tableType !== "relation") {
+            throw new Error("Cannot call .to() on a non-relation table");
+        }
+        return inst.clone({
+            ...inst._zod.def,
+            fields: {
+                ...inst._zod.def.fields,
+                out: to instanceof ZodSurrealdRecordId ? to : recordId(to),
+            },
+        });
+    };
+    // @ts-expect-error - type defined conditionally
+    inst.in = inst.from;
+    // @ts-expect-error - type defined conditionally
+    inst.out = inst.to;
     inst.any = () => {
         return inst.clone({
             ...inst._zod.def,
@@ -357,7 +2237,7 @@ export const SurrealZodTable = core.$constructor("SurrealZodTable", (inst, def)
         });
     };
     inst.normal = () => {
-        return new SurrealZodTableNormal({
+        return inst.clone({
             ...inst._zod.def,
             surreal: {
                 ...inst._zod.def.surreal,
@@ -366,14 +2246,13 @@ export const SurrealZodTable = core.$constructor("SurrealZodTable", (inst, def)
         });
     };
     inst.relation = () => {
-        // @ts-expect-error - id set in constructor
-        return new SurrealZodTableRelation({
+        return inst.clone({
             ...inst._zod.def,
-            // fields: {
-            //   in: recordId().type(any()),
-            //   out: recordId().type(any()),
-            //   ...def.fields,
-            // },
+            fields: {
+                in: recordId().type(any()),
+                out: recordId().type(any()),
+                ...inst._zod.def.fields,
+            },
             surreal: {
                 ...inst._zod.def.surreal,
                 tableType: "relation",
@@ -427,32 +2306,201 @@ export const SurrealZodTable = core.$constructor("SurrealZodTable", (inst, def)
             },
         });
     };
-    // @ts-expect-error - through normalization id is always present
-    inst.record = () => normalized.fields.id;
+    inst.record = () => inst._zod.def.fields.id;
+    inst.table = () => table;
     inst.dto = () => {
-        return inst.clone({
-            ...inst._zod.def,
-            dto: true,
-        });
-    };
-    inst.entity = () => {
-        let id = normalized.fields.id;
-        while (id && id instanceof SurrealZodOptional) {
-            id = id.unwrap();
-        }
-        return inst.clone({
-            ...inst._zod.def,
-            dto: false,
-            fields: {
-                ...normalized.fields,
-                id,
+        return new ZodSurrealObject({
+            type: "object",
+            shape: {
+                ...inst._zod.def.fields,
+                id: optional(inst._zod.def.fields.id),
             },
+            catchall: inst._zod.def.catchall,
+            surreal: {},
         });
     };
     // @ts-expect-error - overloaded
     inst.toSurql = (statement = "define", options) => 
     // @ts-expect-error - overloaded
     tableToSurql(inst, statement, options);
+    // @ts-expect-error - false-positive
+    inst.extend = (extraFields) => {
+        if (!core.util.isPlainObject(extraFields)) {
+            throw new Error("Invalid input to extend: expected a plain object");
+        }
+        const checks = inst._zod.def.checks;
+        const hasChecks = checks && checks.length > 0;
+        if (hasChecks) {
+            throw new Error("Table schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+        }
+        const mergedDef = core.util.mergeDefs(inst._zod.def, {
+            get fields() {
+                const fields = { ...inst._zod.def.fields, ...extraFields };
+                core.util.assignProp(this, "fields", fields); // self-caching
+                return fields;
+            },
+            checks: [],
+        });
+        return inst.clone(mergedDef);
+    };
+    // @ts-expect-error - false-positive
+    inst.safeExtend = (extraFields) => {
+        if (!core.util.isPlainObject(extraFields)) {
+            throw new Error("Invalid input to safeExtend: expected a plain object");
+        }
+        const def = {
+            ...inst._zod.def,
+            get fields() {
+                const fields = { ...inst._zod.def.fields, ...extraFields };
+                core.util.assignProp(this, "fields", fields); // self-caching
+                return fields;
+            },
+            checks: inst._zod.def.checks,
+        };
+        return inst.clone(def);
+    };
+    inst.pick = (mask) => {
+        const currDef = inst._zod.def;
+        const def = core.util.mergeDefs(inst._zod.def, {
+            get fields() {
+                const newFields = {};
+                for (const key in mask) {
+                    if (!(key in currDef.fields)) {
+                        throw new Error(`Unrecognized key: "${key}"`);
+                    }
+                    if (!mask[key])
+                        continue;
+                    newFields[key] = currDef.fields[key];
+                }
+                core.util.assignProp(this, "fields", newFields); // self-caching
+                return newFields;
+            },
+            checks: [],
+        });
+        if ("id" in mask && mask.id === false) {
+            return new classic.ZodObject({
+                type: "object",
+                shape: def.fields,
+                catchall: def.catchall,
+            });
+        }
+        return inst.clone(def);
+    };
+    inst.omit = (mask) => {
+        const currDef = inst._zod.def;
+        const def = core.util.mergeDefs(inst._zod.def, {
+            get fields() {
+                const newFields = { ...currDef.fields };
+                for (const key in mask) {
+                    if (!(key in currDef.fields)) {
+                        throw new Error(`Unrecognized key: "${key}"`);
+                    }
+                    if (!mask[key])
+                        continue;
+                    delete newFields[key];
+                }
+                core.util.assignProp(this, "fields", newFields); // self-caching
+                return newFields;
+            },
+            checks: [],
+        });
+        if ("id" in mask && mask.id === true) {
+            return new classic.ZodObject({
+                type: "object",
+                shape: def.fields,
+                catchall: def.catchall,
+            });
+        }
+        return inst.clone(def);
+    };
+    inst.partial = (mask) => {
+        const def = core.util.mergeDefs(inst._zod.def, {
+            get fields() {
+                const oldFields = inst._zod.def.fields;
+                const fields = { ...oldFields };
+                if (typeof mask === "object") {
+                    for (const key in mask) {
+                        if (!(key in oldFields)) {
+                            throw new Error(`Unrecognized key: "${key}"`);
+                        }
+                        if (!mask[key])
+                            continue;
+                        // if (oldShape[key]!._zod.optin === "optional") continue;
+                        fields[key] = classic.ZodOptional
+                            ? new classic.ZodOptional({
+                                type: "optional",
+                                innerType: oldFields[key],
+                            })
+                            : oldFields[key];
+                    }
+                }
+                else {
+                    for (const key in oldFields) {
+                        if (key === "id" && mask !== true)
+                            continue;
+                        // if (oldShape[key]!._zod.optin === "optional") continue;
+                        fields[key] = classic.ZodOptional
+                            ? new classic.ZodOptional({
+                                type: "optional",
+                                innerType: oldFields[key],
+                            })
+                            : oldFields[key];
+                    }
+                }
+                core.util.assignProp(this, "fields", fields); // self-caching
+                return fields;
+            },
+            checks: [],
+        });
+        if (mask === true ||
+            (typeof mask === "object" && "id" in mask && mask.id === true)) {
+            return new classic.ZodObject({
+                type: "object",
+                shape: def.fields,
+                catchall: def.catchall,
+            });
+        }
+        return inst.clone(def);
+    };
+    inst.required = (mask) => {
+        const def = core.util.mergeDefs(inst._zod.def, {
+            get fields() {
+                const oldFields = inst._zod.def.fields;
+                const fields = { ...oldFields };
+                if (mask) {
+                    for (const key in mask) {
+                        if (!(key in fields)) {
+                            throw new Error(`Unrecognized key: "${key}"`);
+                        }
+                        if (!mask[key])
+                            continue;
+                        if (key === "id")
+                            continue;
+                        // overwrite with non-optional
+                        fields[key] = new classic.ZodNonOptional({
+                            type: "nonoptional",
+                            innerType: oldFields[key],
+                        });
+                    }
+                }
+                else {
+                    for (const key in oldFields) {
+                        if (key === "id")
+                            continue;
+                        // overwrite with non-optional
+                        fields[key] = new classic.ZodNonOptional({
+                            type: "nonoptional",
+                            innerType: oldFields[key],
+                        });
+                    }
+                }
+                core.util.assignProp(this, "fields", fields); // self-caching
+                return fields;
+            },
+            checks: [],
+        });
+        return inst.clone(def);
+    };
     inst._zod.parse = (payload, ctx) => {
         const input = payload.value;
         if (!core.util.isObject(input)) {
@@ -460,7 +2508,6 @@ export const SurrealZodTable = core.$constructor("SurrealZodTable", (inst, def)
                 expected: "object",
                 code: "invalid_type",
                 input,
-                inst,
             });
             return payload;
         }
@@ -489,14 +2536,14 @@ export const SurrealZodTable = core.$constructor("SurrealZodTable", (inst, def)
     return inst;
 });
 export function table(name) {
-    return new SurrealZodTable({
-        type: "any",
+    return new ZodSurrealTable({
+        type: "table",
         name,
         // @ts-expect-error - id set in constructor
         fields: {},
         catchall: unknown(),
+        dto: false,
         surreal: {
-            type: "table",
             tableType: "any",
             schemafull: false,
             drop: false,
@@ -504,100 +2551,30 @@ export function table(name) {
         },
     });
 }
-export const SurrealZodTableNormal = core.$constructor("SurrealZodTableNormal", (inst, def) => {
-    SurrealZodTable.init(inst, def);
-});
 export function normalTable(name) {
     return table(name).normal();
 }
-export const SurrealZodTableRelation = core.$constructor("SurrealZodTableRelation", (inst, def) => {
-    SurrealZodTable.init(inst, def);
-    inst.from = (from) => {
-        return new SurrealZodTableRelation({
-            ...def,
-            fields: {
-                ...def.fields,
-                in: from instanceof SurrealZodRecordId ? from : recordId(from),
-            },
-        });
-    };
-    inst.to = (to) => {
-        return new SurrealZodTableRelation({
-            ...def,
-            fields: {
-                ...def.fields,
-                out: to instanceof SurrealZodRecordId ? to : recordId(to),
-            },
-        });
-    };
-    inst.in = inst.from;
-    inst.out = inst.to;
-    inst.fields = (fields) => {
-        return new SurrealZodTableRelation({
-            ...def,
-            fields: {
-                ...def.fields,
-                ...fields,
-            },
+export const ZodSurrealDuration = core.$constructor("ZodSurrealDuration", (inst, def) => {
+    ZodSurrealType.init(inst, def);
+    ZodSurrealField.init(inst, def);
+    inst._zod.parse = (payload, ctx) => {
+        if (payload.value instanceof Duration) {
+            return payload;
+        }
+        payload.issues.push({
+            code: "invalid_type",
+            expected: "duration",
+            input: null,
         });
+        return payload;
     };
     return inst;
 });
-export function relationTable(name) {
-    return table(name).relation();
-}
-export const SurrealZodOptional = core.$constructor("SurrealZodOptional", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodOptional.init(inst, def);
-    SurrealZodType.init(inst, def);
-    inst.unwrap = () => {
-        return inst._zod.def.innerType;
-    };
-});
-export function optional(innerType) {
-    return new SurrealZodOptional({
-        type: "optional",
-        innerType,
-        surreal: {
-            type: "optional",
-        },
-    });
-}
-export const SurrealZodNonOptional = core.$constructor("SurrealZodNonOptional", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodNonOptional.init(inst, def);
-    SurrealZodType.init(inst, def);
-});
-export function nonoptional(innerType) {
-    return new SurrealZodNonOptional({
-        type: "nonoptional",
-        innerType,
-        surreal: {
-            type: "nonoptional",
-        },
-    });
-}
-export const SurrealZodNullable = core.$constructor("SurrealZodNullable", (inst, def) => {
-    // @ts-expect-error - unknown assertion error
-    core.$ZodNullable.init(inst, def);
-    SurrealZodType.init(inst, def);
-});
-export function nullable(innerType) {
-    return new SurrealZodNullable({
-        type: "nullable",
-        innerType,
+export function duration() {
+    return new ZodSurrealDuration({
+        type: "duration",
         surreal: {
-            type: "nullable",
+            type: "duration",
         },
     });
 }
-/////////////////////////////////////////////////
-/////////////////////////////////////////////////
-//////////                             //////////
-//////////      SurrealZodNullish      //////////
-//////////                             //////////
-/////////////////////////////////////////////////
-/////////////////////////////////////////////////
-export function nullish(innerType) {
-    return optional(nullable(innerType));
-}