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

package/lib/zod/schema.d.ts

@@ -1,314 +1,1879 @@
-/** biome-ignore-all lint/suspicious/noExplicitAny: needed for conversion */
-/** biome-ignore-all lint/style/noNonNullAssertion: needed for conversion */
-import { BoundQuery, RecordId, type RecordIdValue } from "surrealdb";
+import { BoundQuery, DateTime, Duration, RecordId, StringRecordId, Uuid, Table, type RecordIdValue } from "surrealdb";
 import * as core from "zod/v4/core";
 import * as classic from "zod/v4";
 import { type DefineTableOptions, type RemoveTableOptions, type TableInfo, type TableStructure } from "../surql";
-export interface SurrealZodTypeDef extends core.$ZodTypeDef {
-    surrealType?: "any" | "unknown" | "never" | "undefined" | "boolean" | "string" | "number" | "object" | "record_id" | "table";
+import * as _core_ from "./core";
+import { type ParseDbContext, type ParsingEncodingDecodingMethodNames, type ParsingEncodingDecodingMethods } from "./parse";
+import type { UnionToTuple } from "./utils";
+export interface ZodSurrealTypeDef extends _core_.$ZodSurrealTypeDef {
+    surreal: _core_.$ZodSurrealTypeDefInternals;
 }
-export interface SurrealZodInternals {
-    type: string;
+export interface ZodSurrealTypeInternals<out O = unknown, out I = unknown, out DBO = O, out DBI = I> extends _core_.$ZodSurrealTypeInternals<O, I, DBO, DBI> {
+    def: ZodSurrealTypeDef;
 }
-export interface SurrealZodTypeInternals<out O = unknown, out I = unknown, out SurrealInternals extends SurrealZodInternals = SurrealZodInternals> extends core.$ZodTypeInternals<O, I> {
-    def: SurrealZodTypeDef & {
-        surreal: SurrealInternals;
-    };
-}
-export interface SurrealZodType<out O = unknown, out I = unknown, out Internals extends SurrealZodTypeInternals<O, I, SurrealZodInternals> = SurrealZodTypeInternals<O, I, SurrealZodInternals>> extends core.$ZodType<O, I, Internals> {
+export interface ZodSurrealType<out O = unknown, out I = unknown, out DBO = O, out DBI = I, out Internals extends ZodSurrealTypeInternals<O, I, DBO, DBI> = ZodSurrealTypeInternals<O, I, DBO, DBI>> {
+    _zod: Internals;
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    /** Converts this schema to a JSON Schema representation. */
+    toJSONSchema(params?: core.ToJSONSchemaParams): core.ZodStandardJSONSchemaPayload<this>;
+    check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
+    with(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
     clone(def?: Internals["def"], params?: {
         parent: boolean;
     }): this;
-    parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
-    safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): classic.ZodSafeParseResult<core.output<this>>;
-    optional(): SurrealZodOptional<this>;
-    nonoptional(): SurrealZodNonOptional<this>;
-    nullable(): SurrealZodNullable<this>;
-    nullish(): SurrealZodOptional<SurrealZodNullable<this>>;
-}
-export interface _SurrealZodType<Internals extends SurrealZodTypeInternals = SurrealZodTypeInternals> extends SurrealZodType<any, any, Internals> {
-}
-export declare const SurrealZodType: core.$constructor<SurrealZodType>;
-export interface SurrealZodAnyInternals extends core.$ZodAnyInternals {
-    def: core.$ZodAnyInternals["def"] & {
-        surreal: {
-            type: "any";
+    register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [core.$replace<R["_meta"], this>?] : [core.$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
+    brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : _core_.$ZodBranded<this, T, Dir>;
+    parse<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>;
+    encode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>, params?: Ctx): Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>;
+    decode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>, params?: Ctx): Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>;
+    parseAsync<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Promise<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>;
+    encodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>, params?: Ctx): Promise<Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>>;
+    decodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>, params?: Ctx): Promise<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>;
+    safeParse<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>;
+    safeEncode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>, params?: Ctx): classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>>;
+    safeDecode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>, params?: Ctx): classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>;
+    safeParseAsync<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>>;
+    spa<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>>;
+    safeEncodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>>>;
+    safeDecodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>>;
+    optional(): ZodSurrealOptional<this>;
+    exactOptional(): ZodSurrealExactOptional<this>;
+    nonoptional(params?: string | core.$ZodNonOptionalParams): ZodSurrealNonOptional<this>;
+    nullable(): ZodSurrealNullable<this>;
+    nullish(): ZodSurrealOptional<ZodSurrealNullable<this>>;
+    default(def: core.util.NoUndefined<core.output<this>>): ZodSurrealDefault<this>;
+    default(def: () => core.util.NoUndefined<core.output<this>>): ZodSurrealDefault<this>;
+    prefault(def: () => core.input<this>): ZodSurrealPrefault<this>;
+    prefault(def: core.input<this>): ZodSurrealPrefault<this>;
+    array(): ZodSurrealArray<this>;
+    or<T extends _core_.$SomeSurrealType>(option: T): ZodSurrealUnion<[this, T]>;
+    and<T extends _core_.$SomeSurrealType>(incoming: T): ZodSurrealIntersection<this, T>;
+    transform<NewOut>(transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>): ZodSurrealPipe<this, ZodSurrealTransform<Awaited<NewOut>, core.output<this>>>;
+    catch(def: core.output<this>): ZodSurrealCatch<this>;
+    catch(def: (ctx: core.$ZodCatchCtx) => core.output<this>): ZodSurrealCatch<this>;
+    pipe<T extends _core_.$ZodSurrealType<any, core.output<this>>>(target: T | _core_.$ZodSurrealType<any, core.output<this>>): ZodSurrealPipe<this, T>;
+    readonly(): ZodSurrealReadonly<this>;
+}
+export interface _ZodSurrealType<Internals extends ZodSurrealTypeInternals = ZodSurrealTypeInternals> extends ZodSurrealType<any, any, any, any, Internals> {
+}
+export declare const ZodSurrealType: core.$constructor<ZodSurrealType>;
+export interface ZodSurrealFieldDef<O = unknown, I = unknown> extends ZodSurrealTypeDef {
+    type: "field";
+    innerType: _core_.$ZodSurrealType<O, I>;
+    surreal: ZodSurrealTypeDef["surreal"] & {
+        field: {
+            default?: {
+                value: BoundQuery;
+                always?: boolean;
+                parse?: boolean;
+            };
+            readonly?: boolean;
+            comment?: string;
+            assert?: BoundQuery;
+            value?: BoundQuery;
         };
     };
 }
-export interface SurrealZodAny extends _SurrealZodType<SurrealZodAnyInternals> {
+export interface ZodSurrealFieldInternals<out O = unknown, out I = unknown, out DBO = O, out DBI = I> extends ZodSurrealTypeInternals<O, I, DBO, DBI> {
+    def: ZodSurrealFieldDef<O, I>;
 }
-export declare const SurrealZodAny: core.$constructor<SurrealZodAny>;
-export declare function any(): SurrealZodAny;
-export interface SurrealZodUnknownInternals extends core.$ZodUnknownInternals {
-    def: core.$ZodUnknownInternals["def"] & {
-        surreal: {
-            type: "unknown";
-        };
+type UnwrapField<T> = T extends ZodSurrealField<infer I, any, any, any, any, any> ? UnwrapField<I> : T;
+export interface ZodSurrealField<T extends ZodSurrealType = ZodSurrealType, O = core.output<T>, I = core.input<T>, DBO = _core_.dboutput<T>, DBI = _core_.dbinput<T>, Options extends string = ""> extends _core_.$ZodSurrealType<O, I, DBO, DBI, "$default" | "$prefault" | "$defaultAlways" | "$prefaultAlways" extends Options ? Omit<ZodSurrealFieldInternals<O, I, DBO, DBI>, "optin" | "outout"> & {
+    optin: "optional";
+    optout: "optional";
+    dboptin: "optional";
+} & (T extends _core_.OptionalOutSchema ? {
+    dboptout: "optional";
+} : {
+    dboptout?: "optional" | undefined;
+}) : ZodSurrealFieldInternals<O, I, DBO, DBI> & {
+    dboptin: T["_zod"]["optin"];
+    dboptout: T["_zod"]["optout"];
+}>, ZodSurrealFieldMethods<Options> {
+    parse<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>;
+    encode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>, params?: Ctx): Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>;
+    decode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>, params?: Ctx): Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>;
+    parseAsync<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Promise<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>;
+    encodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>, params?: Ctx): Promise<Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>>;
+    decodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>, params?: Ctx): Promise<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>;
+    safeParse<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>;
+    safeEncode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>, params?: Ctx): classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>>;
+    safeDecode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>, params?: Ctx): classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>;
+    safeParseAsync<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>>;
+    spa<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>>;
+    safeEncodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>>>;
+    safeDecodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<this> : core.input<this>, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<this> : core.output<this>>>;
+    unwrap(): UnwrapField<T>;
+}
+type _<T, Options extends string> = ZodSurrealField<T & ZodSurrealType, core.output<T>, core.input<T>, _core_.dboutput<T>, _core_.dbinput<T>, Options>;
+type __<T, O, I, DBO, DBI, Options extends string> = ZodSurrealField<T & ZodSurrealType, O, I, DBO, DBI, Options>;
+export interface ZodSurrealFieldMethods<Options extends string = never> {
+    $default(value: core.util.NoUndefined<core.output<this>> | BoundQuery): __<this, core.output<this> | undefined, core.input<this> | undefined, _core_.dboutput<this>, _core_.dbinput<this> | undefined, Options | "$default" | "$prefault" | "$defaultAlways" | "$prefaultAlways">;
+    $prefault(value: core.util.NoUndefined<core.output<this>> | BoundQuery): __<this, core.output<this> | undefined, core.input<this> | undefined, _core_.dboutput<this>, _core_.dbinput<this> | undefined, Options | "$default" | "$prefault" | "$defaultAlways" | "$prefaultAlways">;
+    $defaultAlways(value: core.util.NoUndefined<core.output<this>> | BoundQuery): __<this, core.output<this> | undefined, core.input<this> | undefined, _core_.dboutput<this>, _core_.dbinput<this> | undefined, Options | "$default" | "$prefault" | "$defaultAlways" | "$prefaultAlways">;
+    $prefaultAlways(value: core.util.NoUndefined<core.output<this>> | BoundQuery): __<this, core.output<this> | undefined, core.input<this> | undefined, _core_.dboutput<this>, _core_.dbinput<this> | undefined, Options | "$default" | "$prefault" | "$defaultAlways" | "$prefaultAlways">;
+    $readonly(readonly?: boolean): _<this, Options | "$readonly">;
+    $value(value: BoundQuery): _<this, Options | "$value">;
+    $assert(assert: BoundQuery): _<this, Options | "$assert">;
+    $comment(comment: string): _<this, Options | "$comment">;
+}
+export declare const ZodSurrealField: core.$constructor<ZodSurrealField>;
+export interface ZodSurrealStringDef extends ZodSurrealTypeDef {
+    type: "string";
+    coerce?: boolean;
+    checks?: core.$ZodCheck<string>[];
+    surreal: {
+        type: "string" | "uuid";
     };
 }
-export interface SurrealZodUnknown extends _SurrealZodType<SurrealZodUnknownInternals> {
+export interface ZodSurrealStringInternals<Input, DBInput = Input> extends ZodSurrealTypeInternals<string, Input, string, DBInput> {
+    def: ZodSurrealStringDef;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    pattern: RegExp;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    isst: core.$ZodIssueInvalidType;
+    bag: core.util.LoosePartial<{
+        minimum: number;
+        maximum: number;
+        patterns: Set<RegExp>;
+        format: string;
+        contentEncoding: string;
+    }>;
 }
-export declare const SurrealZodUnknown: core.$constructor<SurrealZodUnknown>;
-export declare function unknown(): SurrealZodUnknown;
-export interface SurrealZodNeverInternals extends core.$ZodNeverInternals {
-    def: core.$ZodNeverInternals["def"] & {
-        surreal: {
-            type: "never";
-        };
+export interface _ZodSurrealString<Internals extends ZodSurrealStringInternals<unknown> = ZodSurrealStringInternals<unknown>> extends _ZodSurrealType<Internals>, ZodSurrealFieldMethods {
+    format: string | null;
+    minLength: number | null;
+    maxLength: number | null;
+    regex(regex: RegExp, params?: string | core.$ZodCheckRegexParams): this;
+    includes(value: string, params?: string | core.$ZodCheckIncludesParams): this;
+    startsWith(value: string, params?: string | core.$ZodCheckStartsWithParams): this;
+    endsWith(value: string, params?: string | core.$ZodCheckEndsWithParams): this;
+    min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
+    length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
+    nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
+    lowercase(params?: string | core.$ZodCheckLowerCaseParams): this;
+    uppercase(params?: string | core.$ZodCheckUpperCaseParams): this;
+    trim(): this;
+    normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+    slugify(): this;
+}
+export declare const _ZodSurrealString: core.$constructor<_ZodSurrealString>;
+export interface ZodSurrealString extends _ZodSurrealString<ZodSurrealStringInternals<string>> {
+    /** @deprecated Use `z.email()` instead. */
+    email(params?: string | core.$ZodCheckEmailParams): this;
+    /** @deprecated Use `z.url()` instead. */
+    url(params?: string | core.$ZodCheckURLParams): this;
+    /** @deprecated Use `z.jwt()` instead. */
+    jwt(params?: string | core.$ZodCheckJWTParams): this;
+    /** @deprecated Use `z.emoji()` instead. */
+    emoji(params?: string | core.$ZodCheckEmojiParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | core.$ZodCheckGUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuid(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv4(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv6(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv7(params?: string | core.$ZodCheckUUIDParams): this;
+    /** @deprecated Use `z.nanoid()` instead. */
+    nanoid(params?: string | core.$ZodCheckNanoIDParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | core.$ZodCheckGUIDParams): this;
+    /** @deprecated Use `z.cuid()` instead. */
+    cuid(params?: string | core.$ZodCheckCUIDParams): this;
+    /** @deprecated Use `z.cuid2()` instead. */
+    cuid2(params?: string | core.$ZodCheckCUID2Params): this;
+    /** @deprecated Use `z.ulid()` instead. */
+    ulid(params?: string | core.$ZodCheckULIDParams): this;
+    /** @deprecated Use `z.base64()` instead. */
+    base64(params?: string | core.$ZodCheckBase64Params): this;
+    /** @deprecated Use `z.base64url()` instead. */
+    base64url(params?: string | core.$ZodCheckBase64URLParams): this;
+    /** @deprecated Use `z.xid()` instead. */
+    xid(params?: string | core.$ZodCheckXIDParams): this;
+    /** @deprecated Use `z.ksuid()` instead. */
+    ksuid(params?: string | core.$ZodCheckKSUIDParams): this;
+    /** @deprecated Use `z.ipv4()` instead. */
+    ipv4(params?: string | core.$ZodCheckIPv4Params): this;
+    /** @deprecated Use `z.ipv6()` instead. */
+    ipv6(params?: string | core.$ZodCheckIPv6Params): this;
+    /** @deprecated Use `z.cidrv4()` instead. */
+    cidrv4(params?: string | core.$ZodCheckCIDRv4Params): this;
+    /** @deprecated Use `z.cidrv6()` instead. */
+    cidrv6(params?: string | core.$ZodCheckCIDRv6Params): this;
+    /** @deprecated Use `z.e164()` instead. */
+    e164(params?: string | core.$ZodCheckE164Params): this;
+}
+export declare const ZodSurrealString: core.$constructor<ZodSurrealString>;
+export declare function string(params?: string | core.$ZodStringParams): ZodSurrealString;
+export declare function string<T extends string>(params?: string | core.$ZodStringParams): ZodSurrealType<T, T>;
+export interface ZodSurrealStringFormatDef<Format extends string = string> extends ZodSurrealStringDef, core.$ZodCheckStringFormatDef<Format> {
+}
+export interface ZodSurrealStringFormatInternals<Format extends string = string> extends ZodSurrealStringInternals<string>, core.$ZodCheckStringFormatInternals {
+    def: ZodSurrealStringFormatDef<Format>;
+}
+export interface ZodSurrealStringFormat<Format extends string = string> extends _ZodSurrealString<ZodSurrealStringFormatInternals<Format>> {
+}
+export declare const ZodSurrealStringFormat: core.$constructor<ZodSurrealStringFormat>;
+export interface ZodSurrealEmail extends ZodSurrealStringFormat<"email"> {
+}
+export declare const ZodSurrealEmail: core.$constructor<ZodSurrealEmail>;
+export declare function email(params?: string | core.$ZodEmailParams): ZodSurrealEmail;
+export interface ZodSurrealGUIDInternals extends ZodSurrealStringInternals<string | Uuid> {
+    def: ZodSurrealStringFormatDef<"guid">;
+}
+export interface ZodSurrealGUID extends _ZodSurrealString<ZodSurrealGUIDInternals> {
+}
+export declare const ZodSurrealGUID: core.$constructor<ZodSurrealGUID>;
+export declare function guid(params?: string | core.$ZodGUIDParams): ZodSurrealGUID;
+export interface ZodSurrealUUIDInternals extends ZodSurrealStringInternals<string | Uuid> {
+    def: ZodSurrealStringFormatDef<"uuid">;
+}
+export interface ZodSurrealUUID extends _ZodSurrealString<ZodSurrealUUIDInternals> {
+}
+export declare const ZodSurrealUUID: core.$constructor<ZodSurrealUUID>;
+export declare function uuid(params?: string | core.$ZodUUIDParams): ZodSurrealUUID;
+export declare function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodSurrealUUID;
+export declare function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodSurrealUUID;
+export declare function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodSurrealUUID;
+export interface ZodSurrealURLInternals extends ZodSurrealStringInternals<string | URL> {
+    def: ZodSurrealStringFormatDef<"url">;
+}
+export interface ZodSurrealURL extends _ZodSurrealString<ZodSurrealURLInternals> {
+}
+export declare const ZodSurrealURL: core.$constructor<ZodSurrealURL>;
+export declare function url(params?: string | core.$ZodURLParams): ZodSurrealURL;
+export interface ZodSurrealEmoji extends ZodSurrealStringFormat<"emoji"> {
+}
+export declare const ZodSurrealEmoji: core.$constructor<ZodSurrealEmoji>;
+export declare function emoji(params?: string | core.$ZodEmojiParams): ZodSurrealEmoji;
+export interface ZodSurrealNanoID extends ZodSurrealStringFormat<"nanoid"> {
+}
+export declare const ZodSurrealNanoID: core.$constructor<ZodSurrealNanoID>;
+export declare function nanoid(params?: string | core.$ZodNanoIDParams): ZodSurrealNanoID;
+export interface ZodSurrealCUID extends ZodSurrealStringFormat<"cuid"> {
+}
+export declare const ZodSurrealCUID: core.$constructor<ZodSurrealCUID>;
+export declare function cuid(params?: string | core.$ZodCUIDParams): ZodSurrealCUID;
+export interface ZodSurrealCUID2 extends ZodSurrealStringFormat<"cuid2"> {
+}
+export declare const ZodSurrealCUID2: core.$constructor<ZodSurrealCUID2>;
+export declare function cuid2(params?: string | core.$ZodCUID2Params): ZodSurrealCUID2;
+export interface ZodSurrealULID extends ZodSurrealStringFormat<"ulid"> {
+}
+export declare const ZodSurrealULID: core.$constructor<ZodSurrealULID>;
+export declare function ulid(params?: string | core.$ZodULIDParams): ZodSurrealULID;
+export interface ZodSurrealXID extends ZodSurrealStringFormat<"xid"> {
+}
+export declare const ZodSurrealXID: core.$constructor<ZodSurrealXID>;
+export declare function xid(params?: string | core.$ZodXIDParams): ZodSurrealXID;
+export interface ZodSurrealKSUID extends ZodSurrealStringFormat<"ksuid"> {
+}
+export declare const ZodSurrealKSUID: core.$constructor<ZodSurrealKSUID>;
+export declare function ksuid(params?: string | core.$ZodKSUIDParams): ZodSurrealKSUID;
+export interface ZodSurrealIPv4 extends ZodSurrealStringFormat<"ipv4"> {
+}
+export declare const ZodSurrealIPv4: core.$constructor<ZodSurrealIPv4>;
+export declare function ipv4(params?: string | core.$ZodIPv4Params): ZodSurrealIPv4;
+export interface ZodSurrealMAC extends ZodSurrealStringFormat<"mac"> {
+}
+export declare const ZodSurrealMAC: core.$constructor<ZodSurrealMAC>;
+export declare function mac(params?: string | core.$ZodMACParams): ZodSurrealMAC;
+export interface ZodSurrealIPv6 extends ZodSurrealStringFormat<"ipv6"> {
+}
+export declare const ZodSurrealIPv6: core.$constructor<ZodSurrealIPv6>;
+export declare function ipv6(params?: string | core.$ZodIPv6Params): ZodSurrealIPv6;
+export interface ZodSurrealCIDRv4 extends ZodSurrealStringFormat<"cidrv4"> {
+}
+export declare const ZodSurrealCIDRv4: core.$constructor<ZodSurrealCIDRv4>;
+export declare function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodSurrealCIDRv4;
+export interface ZodSurrealCIDRv6 extends ZodSurrealStringFormat<"cidrv6"> {
+}
+export declare const ZodSurrealCIDRv6: core.$constructor<ZodSurrealCIDRv6>;
+export declare function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodSurrealCIDRv6;
+export interface ZodSurrealBase64 extends ZodSurrealStringFormat<"base64"> {
+}
+export declare const ZodSurrealBase64: core.$constructor<ZodSurrealBase64>;
+export declare function base64(params?: string | core.$ZodBase64Params): ZodSurrealBase64;
+export interface ZodSurrealBase64URL extends ZodSurrealStringFormat<"base64url"> {
+}
+export declare const ZodSurrealBase64URL: core.$constructor<ZodSurrealBase64URL>;
+export declare function base64url(params?: string | core.$ZodBase64URLParams): ZodSurrealBase64URL;
+export interface ZodSurrealE164 extends ZodSurrealStringFormat<"e164"> {
+}
+export declare const ZodSurrealE164: core.$constructor<ZodSurrealE164>;
+export declare function e164(params?: string | core.$ZodE164Params): ZodSurrealE164;
+export interface ZodSurrealJWT extends ZodSurrealStringFormat<"jwt"> {
+}
+export declare const ZodSurrealJWT: core.$constructor<ZodSurrealJWT>;
+export declare function jwt(params?: string | core.$ZodJWTParams): ZodSurrealJWT;
+export interface ZodSurrealCustomStringFormatDef<Format extends string = string> extends ZodSurrealStringFormatDef<Format> {
+    fn: (val: string) => unknown;
+}
+export interface ZodSurrealCustomStringFormatInternals<Format extends string = string> extends ZodSurrealStringFormatInternals<Format> {
+    def: ZodSurrealCustomStringFormatDef<Format>;
+}
+export interface ZodSurrealCustomStringFormat<Format extends string = string> extends ZodSurrealStringFormat<Format> {
+    _zod: ZodSurrealCustomStringFormatInternals<Format>;
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodSurrealCustomStringFormat: core.$constructor<ZodSurrealCustomStringFormat>;
+export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => core.util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodSurrealCustomStringFormat<Format>;
+export declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodSurrealCustomStringFormat<"hostname">;
+export declare function hex(_params?: string | core.$ZodStringFormatParams): ZodSurrealCustomStringFormat<"hex">;
+export declare function hash<Alg extends core.util.HashAlgorithm, Enc extends core.util.HashEncoding = "hex">(alg: Alg, params?: {
+    enc?: Enc;
+} & core.$ZodStringFormatParams): ZodSurrealCustomStringFormat<`${Alg}_${Enc}`>;
+export interface ZodSurrealNumberDef extends ZodSurrealTypeDef {
+    type: "number";
+    coerce?: boolean;
+    surreal: {
+        type: "number" | "int" | "float";
     };
 }
-export interface SurrealZodNever extends _SurrealZodType<SurrealZodNeverInternals> {
+export interface ZodSurrealNumberInternals<Input = unknown, DBInput = Input> extends ZodSurrealTypeInternals<number, Input, number, DBInput> {
+    def: ZodSurrealNumberDef;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    pattern: RegExp;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    isst: core.$ZodIssueInvalidType;
+    bag: core.util.LoosePartial<{
+        minimum: number;
+        maximum: number;
+        exclusiveMinimum: number;
+        exclusiveMaximum: number;
+        format: string;
+        pattern: RegExp;
+    }>;
 }
-export declare const SurrealZodNever: core.$constructor<SurrealZodNever>;
-export declare function never(params?: string | core.$ZodNeverParams): SurrealZodNever;
-export interface SurrealZodUndefinedInternals extends core.$ZodUndefinedInternals {
-    def: core.$ZodUndefinedInternals["def"] & {
-        surreal: {
-            type: "undefined";
-        };
+export interface _ZodSurrealNumber<Internals extends ZodSurrealNumberInternals = ZodSurrealNumberInternals> extends _ZodSurrealType<Internals> {
+    gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
+    gte(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
+    /** Alias of `.gte()` */
+    min(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
+    lt(value: number, params?: string | core.$ZodCheckLessThanParams): this;
+    lte(value: number, params?: string | core.$ZodCheckLessThanParams): this;
+    /** Alias of `.lte()` */
+    max(value: number, params?: string | core.$ZodCheckLessThanParams): this;
+    /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
+    int(params?: string | core.$ZodCheckNumberFormatParams): this;
+    /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
+    safe(params?: string | core.$ZodCheckNumberFormatParams): this;
+    positive(params?: string | core.$ZodCheckGreaterThanParams): this;
+    nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
+    negative(params?: string | core.$ZodCheckLessThanParams): this;
+    nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
+    multipleOf(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
+    /** @deprecated Use `.multipleOf()` instead. */
+    step(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
+    /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
+    finite(params?: unknown): this;
+    minValue: number | null;
+    maxValue: number | null;
+    /** @deprecated Check the `format` property instead.  */
+    isInt: boolean;
+    /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
+    isFinite: boolean;
+    format: string | null;
+}
+export interface ZodSurrealNumber extends _ZodSurrealNumber<ZodSurrealNumberInternals<number>>, ZodSurrealFieldMethods {
+}
+export declare const ZodSurrealNumber: core.$constructor<ZodSurrealNumber>;
+export declare function number(params?: string | core.$ZodNumberParams): ZodSurrealNumber;
+export interface ZodSurrealNumberFormatDef extends ZodSurrealNumberDef, core.$ZodCheckNumberFormatDef {
+}
+export interface ZodSurrealNumberFormatInternals extends ZodSurrealNumberInternals<number>, core.$ZodCheckNumberFormatInternals {
+    def: ZodSurrealNumberFormatDef;
+    isst: core.$ZodIssueInvalidType;
+}
+export interface ZodSurrealNumberFormat extends ZodSurrealNumber {
+    _zod: ZodSurrealNumberFormatInternals;
+}
+export declare const ZodSurrealNumberFormat: core.$constructor<ZodSurrealNumberFormat>;
+export interface ZodSurrealInt extends ZodSurrealNumberFormat {
+}
+export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodSurrealInt;
+export interface ZodSurrealFloat32 extends ZodSurrealNumberFormat {
+}
+export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodSurrealFloat32;
+export interface ZodSurrealFloat64 extends ZodSurrealNumberFormat {
+}
+export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodSurrealFloat64;
+export interface ZodSurrealInt32 extends ZodSurrealNumberFormat {
+}
+export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodSurrealInt32;
+export interface ZodSurrealUInt32 extends ZodSurrealNumberFormat {
+}
+export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodSurrealUInt32;
+export interface ZodSurrealBooleanDef extends ZodSurrealTypeDef {
+    type: "boolean";
+    coerce?: boolean;
+    checks?: core.$ZodCheck<boolean>[];
+    surreal: {
+        type: "bool";
     };
 }
-export interface SurrealZodUndefined extends _SurrealZodType<SurrealZodUndefinedInternals> {
+export interface ZodSurrealBooleanInternals<Input = unknown, DBInput = Input> extends ZodSurrealTypeInternals<boolean, Input, boolean, DBInput> {
+    pattern: RegExp;
+    def: ZodSurrealBooleanDef;
+    isst: core.$ZodIssueInvalidType;
 }
-export declare const SurrealZodUndefined: core.$constructor<SurrealZodUndefined>;
-declare function _undefined(params?: string | core.$ZodUndefinedParams): SurrealZodUndefined;
+export interface _ZodSurrealBoolean<T extends ZodSurrealBooleanInternals = ZodSurrealBooleanInternals> extends _ZodSurrealType<T> {
+}
+export interface ZodSurrealBoolean extends _ZodSurrealBoolean<ZodSurrealBooleanInternals<boolean>>, ZodSurrealFieldMethods {
+}
+export declare const ZodSurrealBoolean: core.$constructor<ZodSurrealBoolean>;
+export declare function boolean(params?: string | core.$ZodBooleanParams): ZodSurrealBoolean;
+export interface ZodSurrealBigIntDef extends ZodSurrealTypeDef {
+    type: "bigint";
+    coerce?: boolean;
+    surreal: {
+        type: "int";
+    };
+}
+export interface ZodSurrealBigIntInternals<Input = unknown, DBInput = Input> extends ZodSurrealTypeInternals<bigint, Input, bigint, DBInput> {
+    pattern: RegExp;
+    /** @internal Internal API, use with caution */
+    def: ZodSurrealBigIntDef;
+    isst: core.$ZodIssueInvalidType;
+    bag: core.util.LoosePartial<{
+        minimum: bigint;
+        maximum: bigint;
+        format: string;
+    }>;
+}
+export interface _ZodSurrealBigInt<Internals extends ZodSurrealBigIntInternals = ZodSurrealBigIntInternals> extends _ZodSurrealType<Internals> {
+    gte(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
+    /** Alias of `.gte()` */
+    min(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
+    gt(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
+    lte(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
+    /** Alias of `.lte()` */
+    max(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
+    lt(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;
+    positive(params?: string | core.$ZodCheckGreaterThanParams): this;
+    negative(params?: string | core.$ZodCheckLessThanParams): this;
+    nonpositive(params?: string | core.$ZodCheckLessThanParams): this;
+    nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
+    multipleOf(value: bigint, params?: string | core.$ZodCheckMultipleOfParams): this;
+    minValue: bigint | null;
+    maxValue: bigint | null;
+    format: string | null;
+}
+export interface ZodSurrealBigInt extends _ZodSurrealBigInt<ZodSurrealBigIntInternals<bigint>>, ZodSurrealFieldMethods {
+}
+export declare const ZodSurrealBigInt: core.$constructor<ZodSurrealBigInt>;
+export declare function bigint(params?: string | core.$ZodBigIntParams): ZodSurrealBigInt;
+interface ZodSurrealBigIntFormatDef extends ZodSurrealBigIntDef, core.$ZodCheckBigIntFormatDef {
+    check: "bigint_format";
+}
+export interface ZodSurrealBigIntFormatInternals extends ZodSurrealBigIntInternals<bigint>, core.$ZodCheckBigIntFormatInternals {
+    def: ZodSurrealBigIntFormatDef;
+}
+export interface ZodSurrealBigIntFormat extends ZodSurrealBigInt {
+    _zod: ZodSurrealBigIntFormatInternals;
+}
+export declare const ZodSurrealBigIntFormat: core.$constructor<ZodSurrealBigIntFormat>;
+export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodSurrealBigIntFormat;
+export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodSurrealBigIntFormat;
+export interface ZodSurrealSymbolDef extends ZodSurrealTypeDef {
+    type: "symbol";
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealSymbolInternals extends ZodSurrealTypeInternals<symbol, symbol> {
+    def: ZodSurrealSymbolDef;
+    isst: core.$ZodIssueInvalidType;
+}
+export interface ZodSurrealSymbol extends _ZodSurrealType<ZodSurrealSymbolInternals>, ZodSurrealFieldMethods {
+}
+export declare const ZodSurrealSymbol: core.$constructor<ZodSurrealSymbol>;
+export declare function symbol(params?: string | core.$ZodSymbolParams): ZodSurrealSymbol;
+export interface ZodSurrealUndefinedDef extends ZodSurrealTypeDef {
+    type: "undefined";
+    surreal: {
+        type: "none";
+    };
+}
+export interface ZodSurrealUndefinedInternals extends ZodSurrealTypeInternals<undefined, undefined>, ZodSurrealFieldMethods {
+    pattern: RegExp;
+    def: ZodSurrealUndefinedDef;
+    values: core.util.PrimitiveSet;
+    isst: core.$ZodIssueInvalidType;
+}
+export interface ZodSurrealUndefined extends _ZodSurrealType<ZodSurrealUndefinedInternals>, ZodSurrealFieldMethods {
+}
+export declare const ZodSurrealUndefined: core.$constructor<ZodSurrealUndefined>;
+declare function _undefined(params?: string | core.$ZodUndefinedParams): ZodSurrealUndefined;
 export { _undefined as undefined };
-export interface SurrealZodNullInternals extends core.$ZodNullInternals {
-    def: core.$ZodNullInternals["def"] & {
-        surreal: {
-            type: "null";
-        };
+export interface ZodSurrealNullDef extends ZodSurrealTypeDef {
+    type: "null";
+    surreal: {
+        type: "null";
     };
 }
-export interface SurrealZodNull extends _SurrealZodType<SurrealZodNullInternals> {
+export interface ZodSurrealNullInternals extends ZodSurrealTypeInternals<null, null> {
+    pattern: RegExp;
+    def: ZodSurrealNullDef;
+    values: core.util.PrimitiveSet;
+    isst: core.$ZodIssueInvalidType;
+}
+export interface ZodSurrealNull extends _ZodSurrealType<ZodSurrealNullInternals>, ZodSurrealFieldMethods {
 }
-export declare const SurrealZodNull: core.$constructor<SurrealZodNull>;
-declare function _null(params?: string | core.$ZodNullParams): SurrealZodNull;
+export declare const ZodSurrealNull: core.$constructor<ZodSurrealNull>;
+declare function _null(params?: string | core.$ZodNullParams): ZodSurrealNull;
 export { _null as null };
-export interface SurrealZodBooleanInternals extends core.$ZodBooleanInternals {
-    def: core.$ZodBooleanInternals["def"] & {
-        surreal: {
-            type: "boolean";
-        };
+export interface ZodSurrealAnyDef extends ZodSurrealTypeDef {
+    type: "any";
+    surreal: {
+        type: "any";
     };
 }
-export interface SurrealZodBoolean extends _SurrealZodType<SurrealZodBooleanInternals> {
+export interface ZodSurrealAnyInternals extends ZodSurrealTypeInternals<any, any> {
+    def: ZodSurrealAnyDef;
+    isst: never;
 }
-export declare const SurrealZodBoolean: core.$constructor<SurrealZodBoolean>;
-export declare function boolean(params?: string | core.$ZodBooleanParams): SurrealZodBoolean;
-export interface SurrealZodStringInternals extends core.$ZodStringInternals<string> {
-    def: core.$ZodStringInternals<string>["def"] & {
-        surreal: {
-            type: "string";
-        };
+export interface ZodSurrealAny extends _ZodSurrealType<ZodSurrealAnyInternals>, ZodSurrealFieldMethods {
+}
+export declare const ZodSurrealAny: core.$constructor<ZodSurrealAny>;
+export declare function any(): ZodSurrealAny;
+export interface ZodSurrealUnknownDef extends ZodSurrealTypeDef {
+    type: "unknown";
+    surreal: {
+        type: "any";
     };
 }
-export interface SurrealZodString extends _SurrealZodType<SurrealZodStringInternals> {
+export interface ZodSurrealUnknownInternals extends ZodSurrealTypeInternals<unknown, unknown> {
+    def: ZodSurrealUnknownDef;
+    isst: never;
 }
-export declare const SurrealZodString: core.$constructor<SurrealZodString>;
-export declare function string(params?: string | core.$ZodStringParams): SurrealZodString;
-export interface SurrealZodNumberInternals extends core.$ZodNumberInternals {
-    def: core.$ZodNumberInternals["def"] & {
-        surreal: {
-            type: "number";
-        };
+export interface ZodSurrealUnknown extends _ZodSurrealType<ZodSurrealUnknownInternals>, ZodSurrealFieldMethods {
+}
+export declare const ZodSurrealUnknown: core.$constructor<ZodSurrealUnknown>;
+export declare function unknown(): ZodSurrealUnknown;
+export interface ZodSurrealNeverDef extends ZodSurrealTypeDef {
+    type: "never";
+    surreal: {
+        type: "none";
     };
 }
-export interface SurrealZodNumber extends _SurrealZodType<SurrealZodNumberInternals> {
+export interface ZodSurrealNeverInternals extends ZodSurrealTypeInternals<unknown, unknown> {
+    def: ZodSurrealNeverDef;
+    isst: core.$ZodIssueInvalidType;
 }
-export declare const SurrealZodNumber: core.$constructor<SurrealZodNumber>;
-export declare function number(params?: string | core.$ZodNumberParams): SurrealZodNumber;
-export interface SurrealZodBigIntInternals extends core.$ZodBigIntInternals {
-    def: core.$ZodBigIntInternals["def"] & {
-        surreal: {
-            type: "bigint";
-        };
+export interface ZodSurrealNever extends _ZodSurrealType<ZodSurrealNeverInternals>, ZodSurrealFieldMethods {
+}
+export declare const ZodSurrealNever: core.$constructor<ZodSurrealNever>;
+export declare function never(params?: string | core.$ZodNeverParams): ZodSurrealNever;
+export interface ZodSurrealVoidDef extends ZodSurrealTypeDef {
+    type: "void";
+    surreal: {
+        type: "none";
     };
 }
-export interface SurrealZodBigInt extends _SurrealZodType<SurrealZodBigIntInternals> {
+export interface ZodSurrealVoidInternals extends ZodSurrealTypeInternals<void, void> {
+    def: ZodSurrealVoidDef;
+    isst: core.$ZodIssueInvalidType;
 }
-export declare const SurrealZodBigInt: core.$constructor<SurrealZodBigInt>;
-export declare function bigint(params?: string | core.$ZodBigIntParams): SurrealZodBigInt;
-export interface SurrealZodObjectInternals<out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends core.$ZodObjectInternals<Shape, Config> {
-    def: core.$ZodObjectInternals<Shape, Config>["def"] & {
-        surreal: {
-            type: "object";
-            flexible: boolean;
-        };
+export interface ZodSurrealVoid extends _ZodSurrealType<ZodSurrealVoidInternals>, ZodSurrealFieldMethods {
+}
+export declare const ZodSurrealVoid: core.$constructor<ZodSurrealVoid>;
+declare function _void(params?: string | core.$ZodVoidParams): ZodSurrealVoid;
+export { _void as void };
+export interface ZodSurrealDateDef extends ZodSurrealTypeDef {
+    type: "date";
+    coerce?: boolean;
+    surreal: {
+        type: "datetime";
+    };
+}
+export interface ZodSurrealDateInternals extends ZodSurrealTypeInternals<Date, Date | DateTime> {
+    def: ZodSurrealDateDef;
+    isst: core.$ZodIssueInvalidType;
+    bag: core.util.LoosePartial<{
+        minimum: Date;
+        maximum: Date;
+        format: string;
+    }>;
+}
+export interface ZodSurrealDate extends _ZodSurrealType<ZodSurrealDateInternals>, ZodSurrealFieldMethods {
+    min(value: number | Date | DateTime, params?: string | core.$ZodCheckGreaterThanParams): this;
+    max(value: number | Date | DateTime, params?: string | core.$ZodCheckLessThanParams): this;
+    /** @deprecated Not recommended. */
+    minDate: Date | null;
+    /** @deprecated Not recommended. */
+    maxDate: Date | null;
+}
+export declare const ZodSurrealDate: core.$constructor<ZodSurrealDate>;
+declare function _date(params?: string | core.$ZodDateParams): ZodSurrealDate;
+export { _date as date };
+export interface ZodSurrealArrayDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "array";
+    element: T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealArrayInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.output<T>[], core.input<T>[], _core_.dboutput<T>[], _core_.dbinput<T>[]> {
+    def: ZodSurrealArrayDef<T>;
+    isst: core.$ZodIssueInvalidType;
+}
+export interface ZodSurrealArray<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealArrayInternals<T>>, ZodSurrealFieldMethods {
+    element: T;
+    min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
+    nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
+    length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
+    unwrap(): T;
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodSurrealArray: core.$constructor<ZodSurrealArray>;
+export declare function array<T extends _core_.$ZodSurrealType>(element: T, params?: string | core.$ZodArrayParams): ZodSurrealArray<T>;
+export interface ZodSurrealObjectDef<Shape extends _core_.$ZodSurrealShape = _core_.$ZodSurrealShape> extends ZodSurrealTypeDef {
+    type: "object";
+    shape: Shape;
+    catchall?: _core_.$ZodSurrealType | undefined;
+    surreal: {
+        type?: undefined;
     };
 }
-export interface SurrealZodObject<out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _SurrealZodType<SurrealZodObjectInternals<Shape, Config>> {
-    loose(): this;
+export interface ZodSurrealObjectInternals<out Shape extends _core_.$ZodSurrealShape = _core_.$ZodSurrealShape, out Config extends core.$ZodObjectConfig = core.$ZodObjectConfig> extends ZodSurrealTypeInternals<core.$InferObjectOutput<Shape, Config["out"]>, core.$InferObjectInput<Shape, Config["in"]>, _core_.$InferObjectDbOutput<Shape, Config["out"]>, _core_.$InferObjectDbInput<Shape, Config["in"]>> {
+    def: ZodSurrealObjectDef<Shape>;
+    config: Config;
+    isst: core.$ZodIssueInvalidType | core.$ZodIssueUnrecognizedKeys;
+    propValues: core.util.PropValues;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
+    dboptin?: "optional" | undefined;
+    dboptout?: "optional" | undefined;
+}
+export declare function keyof<T extends ZodSurrealObject>(schema: T): ZodSurrealEnum<core.util.KeysEnum<T["_zod"]["output"]>>;
+export type SafeExtendShape<Base extends _core_.$ZodSurrealShape, Ext extends core.$ZodLooseShape> = {
+    [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
+};
+export interface ZodSurrealObject<out Shape extends _core_.$ZodSurrealShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _ZodSurrealType<ZodSurrealObjectInternals<Shape, Config>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    shape: Shape;
+    keyof(): ZodSurrealEnum<core.util.ToEnum<keyof Shape & string>>;
+    /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+    catchall<T extends _core_.$SomeSurrealType>(schema: T): ZodSurrealObject<Shape, _core_.$catchall<T>>;
+    /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+    passthrough(): ZodSurrealObject<Shape, core.$loose>;
+    /** Consider `z.looseObject(A.shape)` instead */
+    loose(): ZodSurrealObject<Shape, core.$loose>;
+    /** Consider `z.strictObject(A.shape)` instead */
+    strict(): ZodSurrealObject<Shape, core.$strict>;
+    /** This is the default behavior. This method call is likely unnecessary. */
+    strip(): ZodSurrealObject<Shape, core.$strip>;
+    extend<U extends core.$ZodLooseShape>(shape: U): ZodSurrealObject<core.util.Extend<Shape, U>, Config>;
+    safeExtend<U extends core.$ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, core.SomeType>>): ZodSurrealObject<core.util.Extend<Shape, U>, Config>;
     /**
-     * @alias loose
+     * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
      */
-    flexible(): this;
-    strict(): this;
-    extend<U extends core.$ZodLooseShape>(shape: U): SurrealZodObject<core.util.Extend<Shape, U>, Config>;
-    safeExtend<U extends core.$ZodLooseShape>(shape: classic.SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, core.SomeType>>): SurrealZodObject<core.util.Extend<Shape, U>, Config>;
-}
-export declare const SurrealZodObject: core.$constructor<SurrealZodObject>;
-export declare function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>>(shape?: T, params?: string | core.$ZodObjectParams): SurrealZodObject<core.util.Writeable<T>, core.$strip>;
-export type SurrealZodRecordIdValue = SurrealZodAny | SurrealZodUnknown | SurrealZodString | SurrealZodNumber | SurrealZodBigInt | SurrealZodObject;
-export interface SurrealZodRecordIdDef<Table extends string = string, Id extends SurrealZodRecordIdValue = SurrealZodRecordIdValue> extends SurrealZodTypeDef {
-    innerType: Id;
-    table?: Table[];
+    merge<U extends ZodSurrealObject>(other: U): ZodSurrealObject<core.util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
+    pick<M extends core.util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodSurrealObject<core.util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    omit<M extends core.util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodSurrealObject<core.util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    partial(): ZodSurrealObject<{
+        [k in keyof Shape]: ZodSurrealOptional<Shape[k]>;
+    }, Config>;
+    partial<M extends core.util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodSurrealObject<{
+        [k in keyof Shape]: k extends keyof M ? ZodSurrealOptional<Shape[k]> : Shape[k];
+    }, Config>;
+    required(): ZodSurrealObject<{
+        [k in keyof Shape]: ZodSurrealNonOptional<Shape[k]>;
+    }, Config>;
+    required<M extends core.util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodSurrealObject<{
+        [k in keyof Shape]: k extends keyof M ? ZodSurrealNonOptional<Shape[k]> : Shape[k];
+    }, Config>;
+}
+export declare const ZodSurrealObject: core.$constructor<ZodSurrealObject>;
+export declare function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>>(shape?: T, params?: string | core.$ZodObjectParams): ZodSurrealObject<core.util.Writeable<T>, core.$strip>;
+export declare function strictObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodSurrealObject<T, core.$strict>;
+export declare function looseObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodSurrealObject<T, core.$loose>;
+export interface ZodSurrealUnionDef<Options extends readonly _core_.$SomeSurrealType[] = readonly _core_.$ZodSurrealType[]> extends ZodSurrealTypeDef {
+    type: "union";
+    options: Options;
+    inclusive?: boolean;
     surreal: {
-        type: "record_id";
+        type?: undefined;
     };
 }
-export type RecordIdValueOutput<Id extends SurrealZodRecordIdValue> = Id extends {
+export interface ZodSurrealUnionInternals<T extends readonly _core_.$SomeSurrealType[] = readonly _core_.$ZodSurrealType[]> extends ZodSurrealTypeInternals<_core_.$InferUnionOutput<T[number]>, _core_.$InferUnionInput<T[number]>, _core_.$InferUnionDbOutput<T[number]>, _core_.$InferUnionDbInput<T[number]>> {
+    def: ZodSurrealUnionDef<T>;
+    isst: core.$ZodIssueInvalidUnion;
+    pattern: T[number]["_zod"]["pattern"];
+    values: T[number]["_zod"]["values"];
+    optin: _core_.IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
+    optout: _core_.IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
+    dboptin: _core_.IsOptionalDbIn<T[number]> extends false ? "optional" | undefined : "optional";
+    dboptout: _core_.IsOptionalDbOut<T[number]> extends false ? "optional" | undefined : "optional";
+}
+export interface ZodSurrealUnion<T extends readonly _core_.$SomeSurrealType[] = readonly _core_.$ZodSurrealType[]> extends _ZodSurrealType<ZodSurrealUnionInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    options: T;
+}
+export declare const ZodSurrealUnion: core.$constructor<ZodSurrealUnion>;
+export declare function union<const T extends readonly _core_.$SomeSurrealType[]>(options: T, params?: string | core.$ZodUnionParams): ZodSurrealUnion<T>;
+export interface ZodSurrealXorInternals<T extends readonly _core_.$SomeSurrealType[] = readonly _core_.$ZodSurrealType[]> extends ZodSurrealUnionInternals<T> {
+}
+export interface ZodSurrealXor<T extends readonly _core_.$SomeSurrealType[] = readonly _core_.$ZodSurrealType[]> extends _ZodSurrealType<ZodSurrealXorInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    options: T;
+}
+export declare const ZodSurrealXor: core.$constructor<ZodSurrealXor>;
+/** 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 declare function xor<const T extends readonly _core_.$SomeSurrealType[]>(options: T, params?: string | core.$ZodXorParams): ZodSurrealXor<T>;
+export interface ZodSurrealDiscriminatedUnionDef<Options extends readonly _core_.$SomeSurrealType[] = readonly _core_.$ZodSurrealType[], Disc extends string = string> extends ZodSurrealUnionDef<Options> {
+    discriminator: Disc;
+    unionFallback?: boolean;
+}
+export interface ZodSurrealDiscriminatedUnionInternals<Options extends readonly _core_.$SomeSurrealType[] = readonly _core_.$ZodSurrealType[], Disc extends string = string> extends ZodSurrealUnionInternals<Options> {
+    def: ZodSurrealDiscriminatedUnionDef<Options, Disc>;
+    propValues: core.util.PropValues;
+}
+export interface ZodSurrealDiscriminatedUnion<Options extends readonly _core_.$SomeSurrealType[] = readonly _core_.$ZodSurrealType[], Disc extends string = string> extends ZodSurrealUnion<Options>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    _zod: ZodSurrealDiscriminatedUnionInternals<Options, Disc>;
+    def: ZodSurrealDiscriminatedUnionDef<Options, Disc>;
+}
+export declare const ZodSurrealDiscriminatedUnion: core.$constructor<ZodSurrealDiscriminatedUnion>;
+export declare function discriminatedUnion<Types extends readonly [
+    _core_.$ZodSurrealTypeDiscriminable,
+    ..._core_.$ZodSurrealTypeDiscriminable[]
+], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodSurrealDiscriminatedUnion<Types, Disc>;
+export interface ZodSurrealIntersectionDef<Left extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, Right extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "intersection";
+    left: Left;
+    right: Right;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealIntersectionInternals<A extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, B extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>, _core_.dboutput<A> & _core_.dboutput<B>, _core_.dbinput<A> & _core_.dbinput<B>> {
+    def: ZodSurrealIntersectionDef<A, B>;
+    isst: never;
+    optin: A["_zod"]["optin"] | B["_zod"]["optin"];
+    optout: A["_zod"]["optout"] | B["_zod"]["optout"];
+    dboptin: A["_zod"]["dboptin"] | B["_zod"]["dboptin"];
+    dboptout: A["_zod"]["dboptout"] | B["_zod"]["dboptout"];
+}
+export interface ZodSurrealIntersection<A extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, B extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealIntersectionInternals<A, B>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodIntersection: core.$constructor<ZodSurrealIntersection>;
+export declare function intersection<T extends _core_.$SomeSurrealType, U extends _core_.$SomeSurrealType>(left: T, right: U): ZodSurrealIntersection<T, U>;
+export interface ZodSurrealTupleDef<T extends _core_.TupleItems = readonly _core_.$ZodSurrealType[], Rest extends _core_.$SomeSurrealType | null = _core_.$ZodSurrealType | null> extends ZodSurrealTypeDef {
+    type: "tuple";
+    items: T;
+    rest: Rest;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealTupleInternals<T extends _core_.TupleItems = readonly _core_.$ZodSurrealType[], Rest extends _core_.$SomeSurrealType | null = _core_.$ZodSurrealType | null> extends ZodSurrealTypeInternals<_core_.$InferTupleOutputType<T, Rest>, _core_.$InferTupleInputType<T, Rest>, _core_.$InferTupleDbOutputType<T, Rest>, _core_.$InferTupleDbInputType<T, Rest>> {
+    def: ZodSurrealTupleDef<T, Rest>;
+    isst: core.$ZodIssueInvalidType | core.$ZodIssueTooBig<unknown[]> | core.$ZodIssueTooSmall<unknown[]>;
+}
+export interface ZodSurrealTuple<T extends _core_.TupleItems = readonly _core_.$ZodSurrealType[], Rest extends _core_.$SomeSurrealType | null = _core_.$ZodSurrealType | null> extends _ZodSurrealType<ZodSurrealTupleInternals<T, Rest>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    rest<Rest extends _core_.$SomeSurrealType = ZodSurrealType>(rest: Rest): ZodSurrealTuple<T, Rest>;
+}
+export declare const ZodSurrealTuple: core.$constructor<ZodSurrealTuple>;
+export declare function tuple<T extends readonly [_core_.$SomeSurrealType, ..._core_.$SomeSurrealType[]]>(items: T, params?: string | core.$ZodTupleParams): ZodSurrealTuple<T, null>;
+export declare function tuple<T extends readonly [_core_.$SomeSurrealType, ..._core_.$SomeSurrealType[]], Rest extends _core_.$SomeSurrealType>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodSurrealTuple<T, Rest>;
+export declare function tuple(items: [], params?: string | core.$ZodTupleParams): ZodSurrealTuple<[], null>;
+export interface ZodSurrealRecordDef<Key extends _core_.$ZodRecordKey = _core_.$ZodRecordKey, Value extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "record";
+    keyType: Key;
+    valueType: Value;
+    /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+    mode?: "strict" | "loose";
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealRecordInternals<Key extends _core_.$ZodRecordKey = _core_.$ZodRecordKey, Value extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<_core_.$InferZodRecordOutput<Key, Value>, _core_.$InferZodRecordInput<Key, Value>, _core_.$InferZodRecordDbOutput<Key, Value>, _core_.$InferZodRecordDbInput<Key, Value>> {
+    def: ZodSurrealRecordDef<Key, Value>;
+    isst: core.$ZodIssueInvalidType | core.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
+    dboptin?: "optional" | undefined;
+    dboptout?: "optional" | undefined;
+}
+export interface ZodSurrealRecord<Key extends _core_.$ZodRecordKey = _core_.$ZodRecordKey, Value extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealRecordInternals<Key, Value>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    keyType: Key;
+    valueType: Value;
+}
+export declare const ZodSurrealRecord: core.$constructor<ZodSurrealRecord>;
+export declare function record<Key extends _core_.$ZodRecordKey, Value extends _core_.$SomeSurrealType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodSurrealRecord<Key, Value>;
+export declare function partialRecord<Key extends _core_.$ZodRecordKey, Value extends _core_.$SomeSurrealType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodSurrealRecord<Key & core.$partial, Value>;
+export declare function looseRecord<Key extends _core_.$ZodRecordKey, Value extends _core_.$SomeSurrealType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodSurrealRecord<Key, Value>;
+export interface ZodSurrealMapDef<Key extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, Value extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "map";
+    keyType: Key;
+    valueType: Value;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealMapInternals<Key extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, Value extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<Map<core.output<Key>, core.output<Value>>, Map<core.input<Key>, core.input<Value>>, Map<_core_.dboutput<Key>, _core_.dboutput<Value>>, Map<_core_.dbinput<Key>, _core_.dbinput<Value>>> {
+    def: ZodSurrealMapDef<Key, Value>;
+    isst: core.$ZodIssueInvalidType | core.$ZodIssueInvalidKey | core.$ZodIssueInvalidElement<unknown>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
+    dboptin?: "optional" | undefined;
+    dboptout?: "optional" | undefined;
+}
+export interface ZodSurrealMap<Key extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, Value extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealMapInternals<Key, Value>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    keyType: Key;
+    valueType: Value;
+    min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
+    nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
+    max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+    size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
+}
+export declare const ZodSurrealMap: core.$constructor<ZodSurrealMap>;
+export declare function map<Key extends _core_.$SomeSurrealType, Value extends _core_.$SomeSurrealType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodSurrealMap<Key, Value>;
+export interface ZodSurrealSetDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "set";
+    valueType: T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealSetInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<Set<core.output<T>>, Set<core.input<T>>, Set<_core_.dboutput<T>>, Set<_core_.dbinput<T>>> {
+    def: ZodSurrealSetDef<T>;
+    isst: core.$ZodIssueInvalidType;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
+    dboptin?: "optional" | undefined;
+    dboptout?: "optional" | undefined;
+}
+export interface ZodSurrealSet<T extends _core_.$SomeSurrealType = ZodSurrealType> extends _ZodSurrealType<ZodSurrealSetInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
+    nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
+    max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+    size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;
+}
+export declare const ZodSurrealSet: core.$constructor<ZodSurrealSet>;
+export declare function set<Value extends _core_.$SomeSurrealType>(valueType: Value, params?: string | core.$ZodSetParams): ZodSurrealSet<Value>;
+export interface ZodSurrealEnumDef<T extends core.util.EnumLike = core.util.EnumLike> extends ZodSurrealTypeDef {
+    type: "enum";
+    entries: T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealEnumInternals<
+/** @ts-expect-error Cast variance */
+out T extends core.util.EnumLike = core.util.EnumLike> extends ZodSurrealTypeInternals<core.$InferEnumOutput<T>, core.$InferEnumInput<T>, _core_.$InferEnumDbOutput<T>, _core_.$InferEnumDbInput<T>> {
+    def: ZodSurrealEnumDef<T>;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    values: core.util.PrimitiveSet;
+    /** @deprecated Internal API, use with caution (not deprecated) */
+    pattern: RegExp;
+    isst: core.$ZodIssueInvalidValue;
+}
+export interface ZodSurrealEnum<
+/** @ts-expect-error Cast variance */
+out T extends core.util.EnumLike = core.util.EnumLike> extends _ZodSurrealType<ZodSurrealEnumInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    enum: T;
+    options: Array<T[keyof T]>;
+    extract<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodSurrealEnum<core.util.Flatten<Pick<T, U[number]>>>;
+    exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodSurrealEnum<core.util.Flatten<Omit<T, U[number]>>>;
+}
+export declare const ZodSurrealEnum: core.$constructor<ZodSurrealEnum>;
+declare function _enum<const T extends readonly string[]>(values: T, params?: string | core.$ZodEnumParams): ZodSurrealEnum<core.util.ToEnum<T[number]>>;
+declare function _enum<const T extends core.util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodSurrealEnum<T>;
+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 declare function nativeEnum<T extends core.util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodSurrealEnum<T>;
+export interface ZodSurrealLiteralDef<T extends core.util.Literal> extends ZodSurrealTypeDef {
+    type: "literal";
+    values: T[];
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealLiteralInternals<T extends core.util.Literal = core.util.Literal> extends ZodSurrealTypeInternals<T, T> {
+    def: ZodSurrealLiteralDef<T>;
+    values: Set<T>;
+    pattern: RegExp;
+    isst: core.$ZodIssueInvalidValue;
+}
+export interface ZodSurrealLiteral<T extends core.util.Literal = core.util.Literal> extends _ZodSurrealType<ZodSurrealLiteralInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    values: Set<T>;
+    /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+    value: T;
+}
+export declare const ZodSurrealLiteral: core.$constructor<ZodSurrealLiteral>;
+export declare function literal<const T extends ReadonlyArray<core.util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodSurrealLiteral<T[number]>;
+export declare function literal<const T extends core.util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodSurrealLiteral<T>;
+type _File = typeof globalThis extends {
+    File: infer F extends new (...args: any[]) => any;
+} ? InstanceType<F> : {};
+/** Do not reference this directly. */
+export interface File extends _File {
+    readonly type: string;
+    readonly size: number;
+}
+export interface ZodSurrealFileDef extends ZodSurrealTypeDef {
+    type: "file";
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealFileInternals extends ZodSurrealTypeInternals<File, File> {
+    def: ZodSurrealFileDef;
+    isst: core.$ZodIssueInvalidType;
+    bag: core.util.LoosePartial<{
+        minimum: number;
+        maximum: number;
+        mime: core.util.MimeTypes[];
+    }>;
+}
+export interface ZodSurrealFile extends _ZodSurrealType<ZodSurrealFileInternals>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;
+    max(size: number, params?: string | core.$ZodCheckMaxSizeParams): this;
+    mime(types: core.util.MimeTypes | Array<core.util.MimeTypes>, params?: string | core.$ZodCheckMimeTypeParams): this;
+}
+export declare const ZodSurrealFile: core.$constructor<ZodSurrealFile>;
+export declare function file(params?: string | core.$ZodFileParams): ZodSurrealFile;
+export interface ZodSurrealTransformDef extends ZodSurrealTypeDef {
+    type: "transform";
+    transform: (input: unknown, payload: core.ParsePayload<unknown>) => core.util.MaybeAsync<unknown>;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealTransformInternals<O = unknown, I = unknown> extends ZodSurrealTypeInternals<O, I> {
+    def: ZodSurrealTransformDef;
+    isst: never;
+}
+export interface ZodSurrealTransform<O = unknown, I = unknown> extends _ZodSurrealType<ZodSurrealTransformInternals<O, I>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodSurrealTransform: core.$constructor<ZodSurrealTransform>;
+export declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): ZodSurrealTransform<Awaited<O>, I>;
+export interface ZodSurrealOptionalDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "optional";
+    innerType: T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealOptionalInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.output<T> | undefined, core.input<T> | undefined, _core_.dboutput<T> | undefined, _core_.dbinput<T> | undefined> {
+    def: ZodSurrealOptionalDef<T>;
+    optin: "optional";
+    optout: "optional";
+    dboptin: "optional";
+    dboptout: "optional";
+    isst: never;
+    values: T["_zod"]["values"];
+    pattern: T["_zod"]["pattern"];
+}
+export interface ZodSurrealOptional<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealOptionalInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const ZodSurrealOptional: core.$constructor<ZodSurrealOptional>;
+export declare function optional<T extends _core_.$SomeSurrealType>(innerType: T): ZodSurrealOptional<T>;
+export interface ZodSurrealExactOptionalDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealOptionalDef<T> {
+}
+export interface ZodSurrealExactOptionalInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealOptionalInternals<T> {
+    def: ZodSurrealExactOptionalDef<T>;
+    output: core.output<T>;
+    input: core.input<T>;
+    dboutput: _core_.dboutput<T>;
+    dbinput: _core_.dbinput<T>;
+}
+export interface ZodSurrealExactOptional<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealExactOptionalInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const ZodSurrealExactOptional: core.$constructor<ZodSurrealExactOptional>;
+export declare function exactOptional<T extends _core_.$SomeSurrealType>(innerType: T): ZodSurrealExactOptional<T>;
+export interface ZodSurrealNullableDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "nullable";
+    innerType: T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealNullableInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.output<T> | null, core.input<T> | null, _core_.dboutput<T> | null, _core_.dbinput<T> | null> {
+    def: ZodSurrealNullableDef<T>;
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    dboptin: T["_zod"]["dboptin"];
+    dboptout: T["_zod"]["dboptout"];
+    isst: never;
+    values: T["_zod"]["values"];
+    pattern: T["_zod"]["pattern"];
+}
+export interface ZodSurrealNullable<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealNullableInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const ZodSurrealNullable: core.$constructor<ZodSurrealNullable>;
+export declare function nullable<T extends _core_.$SomeSurrealType>(innerType: T): ZodSurrealNullable<T>;
+export declare function nullish<T extends _core_.$SomeSurrealType>(innerType: T): ZodSurrealOptional<ZodSurrealNullable<T>>;
+export interface ZodSurrealDefaultDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "default";
+    innerType: T;
+    /** The default value. May be a getter. */
+    defaultValue: core.util.NoUndefined<core.output<T>>;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealDefaultInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.util.NoUndefined<core.output<T>>, core.input<T> | undefined, core.util.NoUndefined<_core_.dboutput<T>>, _core_.dbinput<T> | undefined> {
+    def: ZodSurrealDefaultDef<T>;
+    optin: "optional";
+    optout?: "optional" | undefined;
+    dboptin: "optional";
+    dboptout?: "optional" | undefined;
+    isst: never;
+    values: T["_zod"]["values"];
+}
+export interface ZodSurrealDefault<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealDefaultInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeDefault(): T;
+}
+export declare const ZodSurrealDefault: core.$constructor<ZodSurrealDefault>;
+export declare function _default<T extends _core_.$SomeSurrealType>(innerType: T, defaultValue: core.util.NoUndefined<core.output<T>> | (() => core.util.NoUndefined<core.output<T>>)): ZodSurrealDefault<T>;
+export interface ZodSurrealPrefaultDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "prefault";
+    innerType: T;
+    /** The default value. May be a getter. */
+    defaultValue: core.input<T>;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealPrefaultInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.util.NoUndefined<core.output<T>>, core.input<T> | undefined, core.util.NoUndefined<_core_.dboutput<T>>, _core_.dbinput<T> | undefined> {
+    def: ZodSurrealPrefaultDef<T>;
+    optin: "optional";
+    optout?: "optional" | undefined;
+    dboptin: "optional";
+    dboptout?: "optional" | undefined;
+    isst: never;
+    values: T["_zod"]["values"];
+}
+export interface ZodSurrealPrefault<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealPrefaultInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const ZodSurrealPrefault: core.$constructor<ZodSurrealPrefault>;
+export declare function prefault<T extends _core_.$SomeSurrealType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodSurrealPrefault<T>;
+export interface ZodSurrealNonOptionalDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "nonoptional";
+    innerType: T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealNonOptionalInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.util.NoUndefined<core.output<T>>, core.util.NoUndefined<core.input<T>>, core.util.NoUndefined<_core_.dboutput<T>>, core.util.NoUndefined<_core_.dbinput<T>>> {
+    def: ZodSurrealNonOptionalDef<T>;
+    isst: core.$ZodIssueInvalidType;
+    values: T["_zod"]["values"];
+    optin: "optional" | undefined;
+    optout: "optional" | undefined;
+    dboptin: "optional" | undefined;
+    dboptout: "optional" | undefined;
+}
+export interface ZodSurrealNonOptional<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealNonOptionalInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const ZodSurrealNonOptional: core.$constructor<ZodSurrealNonOptional>;
+export declare function nonoptional<T extends _core_.$SomeSurrealType>(innerType: T, params?: string | core.$ZodNonOptionalParams): ZodSurrealNonOptional<T>;
+export interface ZodSurrealSuccessDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "success";
+    innerType: T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealSuccessInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<boolean, core.input<T>, boolean, _core_.dbinput<T>> {
+    def: ZodSurrealSuccessDef<T>;
+    isst: never;
+    optin: T["_zod"]["optin"];
+    optout: "optional" | undefined;
+    dboptin: T["_zod"]["dboptin"];
+    dboptout: "optional" | undefined;
+}
+export interface ZodSurrealSuccess<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealSuccessInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const ZodSurrealSuccess: core.$constructor<ZodSurrealSuccess>;
+export declare function success<T extends _core_.$SomeSurrealType>(innerType: T): ZodSurrealSuccess<T>;
+export interface ZodSurrealCatchDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "catch";
+    innerType: T;
+    catchValue: (ctx: core.$ZodCatchCtx) => unknown;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealCatchInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.output<T>, core.input<T>, _core_.dboutput<T>, _core_.dbinput<T>> {
+    def: ZodSurrealCatchDef<T>;
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    dboptin: T["_zod"]["dboptin"];
+    dboptout: T["_zod"]["dboptout"];
+    isst: never;
+    values: T["_zod"]["values"];
+}
+export interface ZodSurrealCatch<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealCatchInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeCatch(): T;
+}
+export declare const ZodSurrealCatch: core.$constructor<ZodSurrealCatch>;
+declare function _catch<T extends _core_.$SomeSurrealType>(innerType: T, catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)): ZodSurrealCatch<T>;
+export { _catch as catch };
+export interface ZodSurrealNaNDef extends ZodSurrealTypeDef {
+    type: "nan";
+    surreal: {
+        type: "number";
+    };
+}
+export interface ZodSurrealNaNInternals extends ZodSurrealTypeInternals<number, number> {
+    def: ZodSurrealNaNDef;
+    isst: core.$ZodIssueInvalidType;
+}
+export interface ZodSurrealNaN extends _ZodSurrealType<ZodSurrealNaNInternals>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodSurrealNaN: core.$constructor<ZodSurrealNaN>;
+export declare function nan(params?: string | core.$ZodNaNParams): ZodSurrealNaN;
+export interface ZodSurrealPipeDef<A extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, B extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "pipe";
+    in: A;
+    out: B;
+    /** Only defined inside $ZodCodec instances. */
+    transform?: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    /** Only defined inside $ZodCodec instances. */
+    reverseTransform?: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealPipeInternals<A extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, B extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.output<B>, core.input<A>, _core_.dboutput<B>, _core_.dbinput<A>> {
+    def: ZodSurrealPipeDef<A, B>;
+    isst: never;
+    values: A["_zod"]["values"];
+    optin: A["_zod"]["optin"];
+    optout: B["_zod"]["optout"];
+    dboptin: A["_zod"]["dboptin"];
+    dboptout: B["_zod"]["dboptout"];
+    propValues: A["_zod"]["propValues"];
+}
+export interface ZodSurrealPipe<A extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, B extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealPipeInternals<A, B>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    in: A;
+    out: B;
+}
+export declare const ZodSurrealPipe: core.$constructor<ZodSurrealPipe>;
+export declare function pipe<const A extends _core_.$SomeSurrealType, B extends ZodSurrealType<unknown, core.output<A>> = ZodSurrealType<unknown, core.output<A>>>(in_: A, out: B | ZodSurrealType<unknown, core.output<A>>): ZodSurrealPipe<A, B>;
+export interface ZodSurrealCodecDef<A extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, B extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealPipeDef<A, B> {
+    transform: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    reverseTransform: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealCodecInternals<A extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, B extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.output<B>, core.input<A>, _core_.dboutput<B>, _core_.dbinput<A>> {
+    def: ZodSurrealCodecDef<A, B>;
+    isst: never;
+    values: A["_zod"]["values"];
+    optin: A["_zod"]["optin"];
+    optout: B["_zod"]["optout"];
+    dboptin: A["_zod"]["dboptin"];
+    dboptout: B["_zod"]["dboptout"];
+    propValues: A["_zod"]["propValues"];
+}
+export interface ZodSurrealCodec<A extends _core_.$SomeSurrealType = _core_.$ZodSurrealType, B extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealPipe<A, B>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    _zod: ZodSurrealCodecInternals<A, B>;
+    def: ZodSurrealCodecDef<A, B>;
+}
+export declare const ZodSurrealCodec: core.$constructor<ZodSurrealCodec>;
+export declare function codec<const A extends _core_.$SomeSurrealType, B extends _core_.$SomeSurrealType = _core_.$ZodSurrealType>(in_: A, out: B, params: {
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
+}): ZodSurrealCodec<A, B>;
+export interface ZodSurrealReadonlyDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "readonly";
+    innerType: T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealReadonlyInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.util.MakeReadonly<core.output<T>>, core.util.MakeReadonly<core.input<T>>, core.util.MakeReadonly<_core_.dboutput<T>>, core.util.MakeReadonly<_core_.dbinput<T>>> {
+    def: ZodSurrealReadonlyDef<T>;
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    dboptin: T["_zod"]["dboptin"];
+    dboptout: T["_zod"]["dboptout"];
+    isst: never;
+    propValues: T["_zod"]["propValues"];
+    values: T["_zod"]["values"];
+}
+export interface ZodSurrealReadonly<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealReadonlyInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const ZodSurrealReadonly: core.$constructor<ZodSurrealReadonly>;
+export declare function readonly<T extends _core_.$SomeSurrealType>(innerType: T): ZodSurrealReadonly<T>;
+export interface ZodSurrealTemplateLiteralDef extends ZodSurrealTypeDef {
+    type: "template_literal";
+    parts: _core_.$ZodSurrealTemplateLiteralPart[];
+    format?: string | undefined;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealTemplateLiteralInternals<Template extends string = string> extends ZodSurrealTypeInternals<Template, Template> {
+    pattern: RegExp;
+    def: ZodSurrealTemplateLiteralDef;
+    isst: core.$ZodIssueInvalidType;
+}
+export interface ZodSurrealTemplateLiteral<Template extends string = string> extends _ZodSurrealType<ZodSurrealTemplateLiteralInternals<Template>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodSurrealTemplateLiteral: core.$constructor<ZodSurrealTemplateLiteral>;
+export declare function templateLiteral<const Parts extends _core_.$ZodSurrealTemplateLiteralPart[]>(parts: Parts, params?: string | core.$ZodTemplateLiteralParams): ZodSurrealTemplateLiteral<_core_.$PartsToTemplateLiteral<Parts>>;
+export interface ZodSurrealLazyDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "lazy";
+    getter: () => T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealLazyInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<core.output<T>, core.input<T>, _core_.dboutput<T>, _core_.dbinput<T>> {
+    def: ZodSurrealLazyDef<T>;
+    isst: never;
+    /** Auto-cached way to retrieve the inner schema */
+    innerType: T;
+    pattern: T["_zod"]["pattern"];
+    propValues: T["_zod"]["propValues"];
+    optin: T["_zod"]["optin"];
+    optout: T["_zod"]["optout"];
+    dboptin: T["_zod"]["dboptin"];
+    dboptout: T["_zod"]["dboptout"];
+}
+export interface ZodSurrealLazy<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealLazyInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const ZodSurrealLazy: core.$constructor<ZodSurrealLazy>;
+export declare function lazy<T extends _core_.$SomeSurrealType>(getter: () => T): ZodSurrealLazy<T>;
+export interface ZodSurrealPromiseDef<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeDef {
+    type: "promise";
+    innerType: T;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealPromiseInternals<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends ZodSurrealTypeInternals<Promise<core.output<T>>, core.util.MaybeAsync<core.input<T>>, Promise<_core_.dboutput<T>>, core.util.MaybeAsync<_core_.dbinput<T>>> {
+    def: ZodSurrealPromiseDef<T>;
+    isst: never;
+}
+export interface ZodSurrealPromise<T extends _core_.$SomeSurrealType = _core_.$ZodSurrealType> extends _ZodSurrealType<ZodSurrealPromiseInternals<T>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const ZodSurrealPromise: core.$constructor<ZodSurrealPromise>;
+export declare function promise<T extends _core_.$SomeSurrealType>(innerType: T): ZodSurrealPromise<T>;
+export interface ZodSurrealFunctionDef<In extends _core_.ZodSurrealFunctionIn = _core_.ZodSurrealFunctionIn, Out extends _core_.ZodSurrealFunctionOut = _core_.ZodSurrealFunctionOut> extends ZodSurrealTypeDef {
+    type: "function";
+    input: In;
+    output: Out;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealFunctionInternals<Args extends _core_.ZodSurrealFunctionIn, Returns extends _core_.ZodSurrealFunctionOut> extends ZodSurrealTypeInternals<_core_.$InferOuterFunctionType<Args, Returns>, _core_.$InferInnerFunctionType<Args, Returns>, _core_.$InferOuterFunctionDbType<Args, Returns>, _core_.$InferInnerFunctionDbType<Args, Returns>> {
+    def: ZodSurrealFunctionDef<Args, Returns>;
+    isst: core.$ZodIssueInvalidType;
+}
+export interface ZodSurrealFunction<Args extends _core_.ZodSurrealFunctionIn = _core_.ZodSurrealFunctionIn, Returns extends _core_.ZodSurrealFunctionOut = _core_.ZodSurrealFunctionOut> extends _ZodSurrealType<ZodSurrealFunctionInternals<Args, Returns>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+    _def: _core_.ZodSurrealFunctionDef<Args, Returns>;
+    _input: _core_.$InferInnerFunctionType<Args, Returns>;
+    _output: _core_.$InferOuterFunctionType<Args, Returns>;
+    _dbinput: _core_.$InferInnerFunctionDbType<Args, Returns>;
+    _dboutput: _core_.$InferOuterFunctionDbType<Args, Returns>;
+    input<const Items extends _core_.TupleItems, const Rest extends _core_.ZodSurrealFunctionOut = _core_.ZodSurrealFunctionOut>(args: Items, rest?: Rest): ZodSurrealFunction<ZodSurrealTuple<Items, Rest>, Returns>;
+    input<NewArgs extends _core_.ZodSurrealFunctionIn>(args: NewArgs): ZodSurrealFunction<NewArgs, Returns>;
+    input(...args: any[]): ZodSurrealFunction<any, Returns>;
+    output<NewReturns extends ZodSurrealType>(output: NewReturns): ZodSurrealFunction<Args, NewReturns>;
+}
+export declare const ZodSurrealFunction: core.$constructor<ZodSurrealFunction>;
+export declare function _function(): ZodSurrealFunction;
+export declare function _function<const In extends ReadonlyArray<ZodSurrealType>>(params: {
+    input: In;
+}): ZodSurrealFunction<ZodSurrealTuple<In, null>, _core_.ZodSurrealFunctionOut>;
+export declare function _function<const In extends ReadonlyArray<ZodSurrealType>, const Out extends _core_.ZodSurrealFunctionOut = _core_.ZodSurrealFunctionOut>(params: {
+    input: In;
+    output: Out;
+}): ZodSurrealFunction<ZodSurrealTuple<In, null>, Out>;
+export declare function _function<const In extends _core_.ZodSurrealFunctionIn = _core_.ZodSurrealFunctionIn>(params: {
+    input: In;
+}): ZodSurrealFunction<In, _core_.ZodSurrealFunctionOut>;
+export declare function _function<const Out extends _core_.ZodSurrealFunctionOut = _core_.ZodSurrealFunctionOut>(params: {
+    output: Out;
+}): ZodSurrealFunction<_core_.ZodSurrealFunctionIn, Out>;
+export declare function _function<In extends _core_.ZodSurrealFunctionIn = _core_.ZodSurrealFunctionIn, Out extends ZodSurrealType = ZodSurrealType>(params?: {
+    input: In;
+    output: Out;
+}): ZodSurrealFunction<In, Out>;
+export { _function as function };
+export interface ZodSurrealCustomDef<O = unknown> extends ZodSurrealTypeDef, core.$ZodCheckDef {
+    type: "custom";
+    check: "custom";
+    path?: PropertyKey[] | undefined;
+    error?: core.$ZodErrorMap | undefined;
+    params?: Record<string, any> | undefined;
+    fn: (arg: O) => unknown;
+    surreal: {
+        type?: undefined;
+    };
+}
+export interface ZodSurrealCustomInternals<O = unknown, I = unknown> extends ZodSurrealTypeInternals<O, I>, core.$ZodCheckInternals<O> {
+    def: ZodSurrealCustomDef;
+    issc: core.$ZodIssue;
+    isst: never;
+    bag: core.util.LoosePartial<{
+        Class: typeof core.util.Class;
+    }>;
+}
+export interface ZodSurrealCustom<O = unknown, I = unknown> extends _ZodSurrealType<ZodSurrealCustomInternals<O, I>>, ZodSurrealFieldMethods {
+    "~standard": core.ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodSurrealCustom: core.$constructor<ZodSurrealCustom>;
+export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
+export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodSurrealCustom<O, O>;
+export declare function refine<T>(fn: (arg: NoInfer<T>) => core.util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
+export declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;
+export declare const describe: typeof core.describe;
+export declare const meta: typeof core.meta;
+type ZodInstanceOfParams = core.Params<ZodSurrealCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
+declare function _instanceof<T extends typeof core.util.Class>(cls: T, params?: ZodInstanceOfParams): ZodSurrealCustom<InstanceType<T>, InstanceType<T>>;
+export { _instanceof as instanceof };
+export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodSurrealCodec<ZodSurrealString, ZodSurrealBoolean>;
+type _ZodSurrealJSONSchema = ZodSurrealUnion<[
+    ZodSurrealString,
+    ZodSurrealNumber,
+    ZodSurrealBoolean,
+    ZodSurrealNull,
+    ZodSurrealArray<ZodSurrealJSONSchema>,
+    ZodSurrealRecord<ZodSurrealString, ZodSurrealJSONSchema>
+]>;
+type _ZodSurrealJSONSchemaInternals = _ZodSurrealJSONSchema["_zod"];
+export interface ZodJSONSchemaInternals extends _ZodSurrealJSONSchemaInternals {
+    output: core.util.JSONType;
+    input: core.util.JSONType;
+    dboutput: core.util.JSONType;
+    dbinput: core.util.JSONType;
+}
+export interface ZodSurrealJSONSchema extends _ZodSurrealJSONSchema {
+    _zod: ZodJSONSchemaInternals;
+}
+export declare function json(params?: string | core.$ZodCustomParams): ZodSurrealJSONSchema;
+export declare function preprocess<A, U extends _core_.$SomeSurrealType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodSurrealPipe<ZodSurrealTransform<A, B>, U>;
+export type ZodSurrealRecordIdValue = ZodSurrealType<RecordIdValue, unknown>;
+export type inferRecordIdValue<Id extends ZodSurrealRecordIdValue> = Id extends {
     _zod: {
         output: any;
     };
 } ? Id["_zod"]["output"] : RecordIdValue;
-export interface SurrealZodRecordIdInternals<Table extends string = string, Id extends SurrealZodRecordIdValue = SurrealZodRecordIdValue> extends SurrealZodTypeInternals<RecordId<Table, RecordIdValueOutput<Id>>, RecordIdValue> {
-    def: SurrealZodRecordIdDef<Table, Id>;
+export type inferRecordIdTable<T extends ZodSurrealdRecordId<string, any>> = T extends ZodSurrealdRecordId<infer N> ? N : never;
+export interface ZodSurrealRecordIdDef<Table extends string = string, Id extends ZodSurrealRecordIdValue = ZodSurrealRecordIdValue> extends ZodSurrealTypeDef {
+    innerType: Id;
+    table?: Table[];
+    surreal: {
+        type?: undefined;
+    };
+}
+interface ZodSurrealRecordIdExtras {
+    output?: null | undefined;
+    input?: null | undefined;
+    dboutput?: null | undefined;
+    dbinput?: null | undefined;
 }
-export interface SurrealZodRecordId<Table extends string = string, Id extends SurrealZodRecordIdValue = SurrealZodRecordIdValue> extends _SurrealZodType<SurrealZodRecordIdInternals<Table, Id>> {
-    anytable(): SurrealZodRecordId<string, Id>;
-    table<NewTable extends string | string[]>(table: NewTable): SurrealZodRecordId<NewTable extends string ? NewTable : NewTable[number], Id>;
-    type<NewType extends SurrealZodRecordIdValue>(innerType: NewType): SurrealZodRecordId<Table, NewType>;
+export interface ZodSurrealRecordIdInternals<Table extends string = string, Id extends ZodSurrealRecordIdValue = ZodSurrealRecordIdValue, Extras extends ZodSurrealRecordIdExtras = {}> extends ZodSurrealTypeInternals<RecordId<Table, core.output<Id>> | (Extras extends {
+    output: infer Output;
+} ? Output : never), RecordId<Table, core.output<Id>> | StringRecordId | (Extras extends {
+    input: infer Input;
+} ? Input : never), RecordId<Table, _core_.dboutput<Id>> | (Extras extends {
+    dboutput: infer DBOutput;
+} ? DBOutput : never), RecordId<Table, _core_.dboutput<Id>> | StringRecordId | (Extras extends {
+    dbinput: infer DBInput;
+} ? DBInput : never)> {
+    def: ZodSurrealRecordIdDef<Table, Id>;
 }
-export declare const SurrealZodRecordId: core.$constructor<SurrealZodRecordId>;
-export declare function recordId<const W extends string | string[]>(what?: W, innerType?: SurrealZodRecordIdValue): SurrealZodRecordId<W extends string ? W : W[number]>;
-export type inferRecordIdTable<T extends SurrealZodRecordId<string, any>> = T extends SurrealZodRecordId<infer N> ? N : never;
+type ZodSurrealRecordIdTrait<Tb extends string, Id extends ZodSurrealRecordIdValue, Extras extends ZodSurrealRecordIdExtras = {}> = string extends Tb ? ZodSurrealRecordIdValue extends Id ? {
+    parse<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): RecordId<OverrideTb, OverrideId>;
+    parseAsync<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): Promise<RecordId<OverrideTb, OverrideId>>;
+    safeParse<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<OverrideTb, OverrideId>>;
+    safeParseAsync<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<OverrideTb, OverrideId>>>;
+    decode<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(id: RecordId<NoInfer<OverrideTb>, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): RecordId<OverrideTb, OverrideId>;
+    decodeAsync<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(id: RecordId<NoInfer<OverrideTb>, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): Promise<RecordId<OverrideTb, OverrideId>>;
+    safeDecode<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(id: RecordId<NoInfer<OverrideTb>, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<OverrideTb, OverrideId>>;
+    safeDecodeAsync<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(id: RecordId<NoInfer<OverrideTb>, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<OverrideTb, OverrideId>>>;
+    fromParts<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<OverrideTb>, id: NoInfer<OverrideId>, params?: ParseDbContext): RecordId<OverrideTb, OverrideId>;
+    fromPartsAsync<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<OverrideTb>, id: NoInfer<OverrideId>, params?: ParseDbContext): Promise<RecordId<OverrideTb, OverrideId>>;
+    safeFromParts<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<OverrideTb>, id: NoInfer<OverrideId>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<OverrideTb, OverrideId>>;
+    safeFromPartsAsync<OverrideTb extends string = Tb, OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<OverrideTb>, id: NoInfer<OverrideId>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<OverrideTb, OverrideId>>>;
+    parse<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): Override;
+    parseAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): Promise<Override>;
+    safeParse<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<Override>;
+    safeParseAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<Override>>;
+    decode<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(id: NoInfer<Override> | StringRecordId, params?: ParseDbContext): Override;
+    decodeAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(id: NoInfer<Override> | StringRecordId, params?: ParseDbContext): Promise<Override>;
+    safeDecode<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(id: NoInfer<Override> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<Override>;
+    safeDecodeAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(id: NoInfer<Override> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<Override>>;
+    fromParts<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Override["table"]["name"]>, id: NoInfer<Override["id"]>, params?: ParseDbContext): Override;
+    fromPartsAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Override["table"]["name"]>, id: NoInfer<Override["id"]>, params?: ParseDbContext): Promise<Override>;
+    safeFromParts<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Override["table"]["name"]>, id: NoInfer<Override["id"]>, params?: ParseDbContext): classic.ZodSafeParseResult<Override>;
+    safeFromPartsAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Override["table"]["name"]>, id: NoInfer<Override["id"]>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<Override>>;
+} : {
+    parse<OverrideTb extends string = Tb>(data: unknown, params?: ParseDbContext): RecordId<OverrideTb, core.output<Id>>;
+    parseAsync<OverrideTb extends string = Tb>(data: unknown, params?: ParseDbContext): Promise<RecordId<OverrideTb, core.output<Id>>>;
+    safeParse<OverrideTb extends string = Tb>(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<OverrideTb, core.output<Id>>>;
+    safeParseAsync<OverrideTb extends string = Tb>(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<OverrideTb, core.output<Id>>>>;
+    decode<OverrideTb extends string = Tb>(data: RecordId<NoInfer<OverrideTb>, core.output<Id>> | StringRecordId, params?: ParseDbContext): RecordId<OverrideTb, core.output<Id>>;
+    decodeAsync<OverrideTb extends string = Tb>(data: RecordId<NoInfer<OverrideTb>, core.output<Id>> | StringRecordId, params?: ParseDbContext): Promise<RecordId<OverrideTb, core.output<Id>>>;
+    safeDecode<OverrideTb extends string = Tb>(data: RecordId<NoInfer<OverrideTb>, core.output<Id>> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<OverrideTb, core.output<Id>>>;
+    safeDecodeAsync<OverrideTb extends string = Tb>(data: RecordId<NoInfer<OverrideTb>, core.output<Id>> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<OverrideTb, core.output<Id>>>>;
+    fromParts<OverrideTb extends string = Tb>(table: NoInfer<OverrideTb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): RecordId<OverrideTb, core.output<Id>>;
+    fromPartsAsync<OverrideTb extends string = Tb>(table: NoInfer<OverrideTb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<RecordId<OverrideTb, core.output<Id>>>;
+    safeFromParts<OverrideTb extends string = Tb>(table: NoInfer<OverrideTb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<OverrideTb, core.output<Id>>>;
+    safeFromPartsAsync<OverrideTb extends string = Tb>(table: NoInfer<OverrideTb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<OverrideTb, core.output<Id>>>>;
+    parse<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): RecordId<Override["table"]["name"], core.output<Id>>;
+    parseAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): Promise<RecordId<Override["table"]["name"], core.output<Id>>>;
+    safeParse<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Override["table"]["name"], core.output<Id>>>;
+    safeParseAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Override["table"]["name"], core.output<Id>>>>;
+    decode<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Override["table"]["name"], core.output<Id>> | StringRecordId, params?: ParseDbContext): RecordId<Override["table"]["name"], core.output<Id>>;
+    decodeAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Override["table"]["name"], core.output<Id>> | StringRecordId, params?: ParseDbContext): Promise<RecordId<Override["table"]["name"], core.output<Id>>>;
+    safeDecode<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Override["table"]["name"], core.output<Id>> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Override["table"]["name"], core.output<Id>>>;
+    safeDecodeAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Override["table"]["name"], core.output<Id>> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Override["table"]["name"], core.output<Id>>>>;
+    fromParts<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Override["table"]["name"]>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): RecordId<Override["table"]["name"], core.output<Id>>;
+    fromPartsAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Override["table"]["name"]>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<RecordId<Override["table"]["name"], core.output<Id>>>;
+    safeFromParts<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Override["table"]["name"]>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Override["table"]["name"], core.output<Id>>>;
+    safeFromPartsAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Override["table"]["name"]>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Override["table"]["name"], core.output<Id>>>>;
+} : UnionToTuple<Tb> extends {
+    length: 1;
+} ? ZodSurrealRecordIdValue extends Id ? {
+    parse<OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): RecordId<Tb, OverrideId>;
+    parseAsync<OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): Promise<RecordId<Tb, OverrideId>>;
+    safeParse<OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>;
+    safeParseAsync<OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>>;
+    decode<OverrideId extends RecordIdValue = core.output<Id>>(data: RecordId<Tb, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): RecordId<Tb, OverrideId>;
+    decodeAsync<OverrideId extends RecordIdValue = core.output<Id>>(data: RecordId<Tb, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): Promise<RecordId<Tb, OverrideId>>;
+    safeDecode<OverrideId extends RecordIdValue = core.output<Id>>(data: RecordId<Tb, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>;
+    safeDecodeAsync<OverrideId extends RecordIdValue = core.output<Id>>(data: RecordId<Tb, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>>;
+    fromParts<OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<Tb>, id: NoInfer<OverrideId>, params?: ParseDbContext): RecordId<Tb, OverrideId>;
+    fromPartsAsync<OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<Tb>, id: NoInfer<OverrideId>, params?: ParseDbContext): Promise<RecordId<Tb, OverrideId>>;
+    safeFromParts<OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<Tb>, id: NoInfer<OverrideId>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>;
+    safeFromPartsAsync<OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<Tb>, id: NoInfer<OverrideId>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>>;
+    fromId<OverrideId extends RecordIdValue = core.output<Id>>(id: NoInfer<OverrideId>, params?: ParseDbContext): RecordId<Tb, OverrideId>;
+    fromIdAsync<OverrideId extends RecordIdValue = core.output<Id>>(id: NoInfer<OverrideId>, params?: ParseDbContext): Promise<RecordId<Tb, OverrideId>>;
+    safeFromId<OverrideId extends RecordIdValue = core.output<Id>>(id: NoInfer<OverrideId>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>;
+    safeFromIdAsync<OverrideId extends RecordIdValue = core.output<Id>>(id: NoInfer<OverrideId>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>>;
+    parse<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): RecordId<Tb, Override["id"]>;
+    parseAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): Promise<RecordId<Tb, Override["id"]>>;
+    safeParse<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>;
+    safeParseAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>>;
+    decode<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Tb, Override["id"]> | StringRecordId, params?: ParseDbContext): RecordId<Tb, Override["id"]>;
+    decodeAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Tb, Override["id"]> | StringRecordId, params?: ParseDbContext): Promise<RecordId<Tb, Override["id"]>>;
+    safeDecode<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Tb, Override["id"]> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>;
+    safeDecodeAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Tb, Override["id"]> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>>;
+    fromParts<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Tb>, id: NoInfer<Override["id"]>, params?: ParseDbContext): RecordId<Tb, Override["id"]>;
+    fromPartsAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Tb>, id: NoInfer<Override["id"]>, params?: ParseDbContext): Promise<RecordId<Tb, Override["id"]>>;
+    safeFromParts<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Tb>, id: NoInfer<Override["id"]>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>;
+    safeFromPartsAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Tb>, id: NoInfer<Override["id"]>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>>;
+    fromId<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(id: NoInfer<Override["id"]>, params?: ParseDbContext): RecordId<Tb, Override["id"]>;
+    fromIdAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(id: NoInfer<Override["id"]>, params?: ParseDbContext): Promise<RecordId<Tb, Override["id"]>>;
+    safeFromId<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(id: NoInfer<Override["id"]>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>;
+    safeFromIdAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(id: NoInfer<Override["id"]>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>>;
+} : {
+    parse(data: unknown, params?: ParseDbContext): RecordId<Tb, core.output<Id>>;
+    parseAsync(data: unknown, params?: ParseDbContext): Promise<RecordId<Tb, core.output<Id>>>;
+    safeParse(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>;
+    safeParseAsync(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>>;
+    decode(data: RecordId<Tb, core.output<Id>> | StringRecordId, params?: ParseDbContext): RecordId<Tb, core.output<Id>>;
+    decodeAsync(data: RecordId<Tb, core.output<Id>> | StringRecordId, params?: ParseDbContext): Promise<RecordId<Tb, core.output<Id>>>;
+    safeDecode(data: RecordId<Tb, core.output<Id>> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>;
+    safeDecodeAsync(data: RecordId<Tb, core.output<Id>> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>>;
+    fromParts(table: NoInfer<Tb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): RecordId<Tb, core.output<Id>>;
+    fromPartsAsync(table: NoInfer<Tb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<RecordId<Tb, core.output<Id>>>;
+    safeFromParts(table: NoInfer<Tb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>;
+    safeFromPartsAsync(table: NoInfer<Tb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>>;
+    fromId(id: NoInfer<core.output<Id>>, params?: ParseDbContext): RecordId<Tb, core.output<Id>>;
+    fromIdAsync(id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<RecordId<Tb, core.output<Id>>>;
+    safeFromId(id: NoInfer<core.output<Id>>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>;
+    safeFromIdAsync(id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>>;
+} : ZodSurrealRecordIdValue extends Id ? {
+    parse<OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): RecordId<Tb, OverrideId>;
+    parseAsync<OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): Promise<RecordId<Tb, OverrideId>>;
+    safeParse<OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>;
+    safeParseAsync<OverrideId extends RecordIdValue = core.output<Id>>(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>>;
+    decode<OverrideId extends RecordIdValue = core.output<Id>>(data: RecordId<Tb, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): RecordId<Tb, OverrideId>;
+    decodeAsync<OverrideId extends RecordIdValue = core.output<Id>>(data: RecordId<Tb, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): Promise<RecordId<Tb, OverrideId>>;
+    safeDecode<OverrideId extends RecordIdValue = core.output<Id>>(data: RecordId<Tb, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>;
+    safeDecodeAsync<OverrideId extends RecordIdValue = core.output<Id>>(data: RecordId<Tb, NoInfer<OverrideId>> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>>;
+    fromParts<OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<Tb>, id: NoInfer<OverrideId>, params?: ParseDbContext): RecordId<Tb, OverrideId>;
+    fromPartsAsync<OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<Tb>, id: NoInfer<OverrideId>, params?: ParseDbContext): Promise<RecordId<Tb, OverrideId>>;
+    safeFromParts<OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<Tb>, id: NoInfer<OverrideId>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>;
+    safeFromPartsAsync<OverrideId extends RecordIdValue = core.output<Id>>(table: NoInfer<Tb>, id: NoInfer<OverrideId>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, OverrideId>>>;
+    parse<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): RecordId<Tb, Override["id"]>;
+    parseAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): Promise<RecordId<Tb, Override["id"]>>;
+    safeParse<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>;
+    safeParseAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>>;
+    decode<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Tb, Override["id"]> | StringRecordId, params?: ParseDbContext): RecordId<Tb, Override["id"]>;
+    decodeAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Tb, Override["id"]> | StringRecordId, params?: ParseDbContext): Promise<RecordId<Tb, Override["id"]>>;
+    safeDecode<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Tb, Override["id"]> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>;
+    safeDecodeAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(data: RecordId<Tb, Override["id"]> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>>;
+    fromParts<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Tb>, id: NoInfer<Override["id"]>, params?: ParseDbContext): RecordId<Tb, Override["id"]>;
+    fromPartsAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Tb>, id: NoInfer<Override["id"]>, params?: ParseDbContext): Promise<RecordId<Tb, Override["id"]>>;
+    safeFromParts<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Tb>, id: NoInfer<Override["id"]>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>;
+    safeFromPartsAsync<Override extends RecordId<string, RecordIdValue> = RecordId<Tb, core.output<Id>>>(table: NoInfer<Tb>, id: NoInfer<Override["id"]>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, Override["id"]>>>;
+} : {
+    parse(data: unknown, params?: ParseDbContext): RecordId<Tb, core.output<Id>>;
+    parseAsync(data: unknown, params?: ParseDbContext): Promise<RecordId<Tb, core.output<Id>>>;
+    safeParse(data: unknown, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>;
+    safeParseAsync(data: unknown, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>>;
+    decode(data: RecordId<Tb, core.output<Id>> | StringRecordId, params?: ParseDbContext): RecordId<Tb, core.output<Id>>;
+    decodeAsync(data: RecordId<Tb, core.output<Id>> | StringRecordId, params?: ParseDbContext): Promise<RecordId<Tb, core.output<Id>>>;
+    safeDecode(data: RecordId<Tb, core.output<Id>> | StringRecordId, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>;
+    safeDecodeAsync(data: RecordId<Tb, core.output<Id>> | StringRecordId, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>>;
+    fromParts(table: NoInfer<Tb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): RecordId<Tb, core.output<Id>>;
+    fromPartsAsync(table: NoInfer<Tb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<RecordId<Tb, core.output<Id>>>;
+    safeFromParts(table: NoInfer<Tb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>;
+    safeFromPartsAsync(table: NoInfer<Tb>, id: NoInfer<core.output<Id>>, params?: ParseDbContext): Promise<classic.ZodSafeParseResult<RecordId<Tb, core.output<Id>>>>;
+};
+export type ZodSurrealdRecordId<Table extends string = string, Id extends ZodSurrealRecordIdValue = ZodSurrealRecordIdValue, Extras extends ZodSurrealRecordIdExtras = {}> = Omit<_ZodSurrealType<ZodSurrealRecordIdInternals<Table, Id, Extras>>, ParsingEncodingDecodingMethodNames | "optional" | "nullable" | "nullish" | "nonoptional"> & ZodSurrealRecordIdTrait<Table, Id, Extras> & {
+    anytable(): ZodSurrealdRecordId<string, Id, Extras>;
+    table<const NewTable extends string | string[]>(table: NewTable): ZodSurrealdRecordId<NewTable extends string ? NewTable : NewTable[number], Id, Extras>;
+    /** @alias id */
+    type<NewType extends ZodSurrealRecordIdValue>(innerType: NewType): ZodSurrealdRecordId<Table, NewType, Extras>;
+    /** @alias value */
+    id<NewType extends ZodSurrealRecordIdValue>(innerType: NewType): ZodSurrealdRecordId<Table, NewType, Extras>;
+    /** @alias type */
+    value<NewType extends ZodSurrealRecordIdValue>(innerType: NewType): ZodSurrealdRecordId<Table, NewType, Extras>;
+    optional(): ZodSurrealdRecordId<Table, Id, Omit<Extras, "input" | "output"> & {
+        output: undefined | (Extras extends {
+            output: infer O;
+        } ? O : never);
+        input: undefined | (Extras extends {
+            input: infer I;
+        } ? I : never);
+    }>;
+    nullable(): ZodSurrealdRecordId<Table, Id, Omit<Extras, "input" | "output"> & {
+        output: null | (Extras extends {
+            output: infer O;
+        } ? O : never);
+        input: null | (Extras extends {
+            input: infer I;
+        } ? I : never);
+    }>;
+    nullish(): ZodSurrealdRecordId<Table, Id, Omit<Extras, "input" | "output"> & {
+        output: null | undefined | (Extras extends {
+            output: infer O;
+        } ? O : never);
+        input: null | undefined | (Extras extends {
+            input: infer I;
+        } ? I : never);
+    }>;
+    nonoptional(): ZodSurrealdRecordId<Table, Id, Omit<Extras, "input" | "output"> & {
+        output: Extras extends {
+            output: infer O;
+        } ? Exclude<O, undefined> : never;
+        input: Extras extends {
+            input: infer I;
+        } ? Exclude<I, undefined> : never;
+    }>;
+};
+export declare const ZodSurrealdRecordId: core.$constructor<ZodSurrealdRecordId>;
+export declare function recordId<const W extends string | string[], I extends ZodSurrealRecordIdValue = ZodSurrealRecordIdValue>(what?: W, innerType?: I): ZodSurrealdRecordId<W extends string ? W : W[number], I>;
 export type SurrealZodTableFields = {
-    [key: string]: SurrealZodType;
+    [key: string]: _core_.$ZodSurrealType;
+};
+export type SurrealZodTableRelationFields = {
+    [K in "in" | "out"]?: ZodSurrealdRecordId<string, ZodSurrealRecordIdValue>;
+} & {
+    [key: string]: _core_.$ZodSurrealType;
 };
 /**
  * Normalizes the fields of a table schema to include the id field if it is not present.
  * If the id field is present, it will be normalized using the table name and the inner type.
  */
-type NormalizedIdField<TableName extends string, Fields extends SurrealZodTableFields, FieldName extends string> = Fields extends {
-    [K in FieldName]: SurrealZodType;
-} ? Fields[FieldName] extends SurrealZodRecordId<infer _N, infer T> ? Omit<Fields, FieldName> & {
-    [K in FieldName]: SurrealZodRecordId<TableName, T>;
-} : Fields[FieldName] extends SurrealZodRecordIdValue ? Omit<Fields, FieldName> & {
-    [K in FieldName]: SurrealZodRecordId<TableName, Fields[FieldName]>;
-} : Omit<Fields, FieldName> & {
-    [K in FieldName]: SurrealZodRecordId<TableName>;
-} : Fields & {
-    [K in FieldName]: SurrealZodRecordId<TableName>;
+type NormalizedIdField<TableName extends string, Fields extends SurrealZodTableFields, FieldName extends string> = {
+    [K in keyof Fields | FieldName]: K extends FieldName ? Fields extends {
+        [P in FieldName]: infer F;
+    } ? F extends ZodSurrealdRecordId<any, infer T> ? ZodSurrealdRecordId<TableName, T> : F extends ZodSurrealRecordIdValue ? ZodSurrealdRecordId<TableName, F> : ZodSurrealdRecordId<TableName> : ZodSurrealdRecordId<TableName> : K extends keyof Fields ? Fields[K] : never;
 };
-export type NormalizedFields<TableName extends string = string, Fields extends SurrealZodTableFields = {}> = core.util.Prettify<NormalizedIdField<TableName, Fields, "id">>;
-type SetConfig<Key extends string, Value> = {
+export type NormalizedFields<TableName extends string = string, Fields extends SurrealZodTableFields = {}> = NormalizedIdField<TableName, Fields, "id">;
+export type SetConfig<Key extends string, Value> = {
     [key in Key]: Value;
 };
-type MergeConfig<A extends Partial<SurrealZodTableConfig>, B extends Partial<SurrealZodTableConfig>> = core.util.Prettify<Omit<A, keyof B> & B>;
-type SurrealZodTableConfigSchemafull = SetConfig<"catchall", {}>;
-type SurrealZodTableConfigSchemaless = SetConfig<"catchall", Record<string, SurrealZodType>>;
-type SurrealZodTableConfig = {
+export type MergeConfig<A extends Partial<SurrealZodTableConfig>, B extends Partial<SurrealZodTableConfig>> = Omit<A, keyof B> & B;
+export type SurrealZodTableConfigSchemafull = SetConfig<"catchall", {}>;
+export type SurrealZodTableConfigSchemaless = SetConfig<"catchall", Record<string, unknown>>;
+export type SurrealZodTableConfig = {
     catchall: any;
-    dto: boolean;
 };
-export interface SurrealZodTableDef<Name extends string = string, Fields extends SurrealZodTableFields = {}, Config extends SurrealZodTableConfig = SurrealZodTableConfig> extends SurrealZodTypeDef {
+export interface SurrealZodTableDef<Name extends string = string, Fields extends SurrealZodTableFields = {}, Config extends SurrealZodTableConfig = SurrealZodTableConfig> extends ZodSurrealTypeDef {
+    type: "table";
     name: Name;
-    fields: (Config["dto"] extends true ? Omit<NormalizedFields<Name, Fields>, "id"> & {
-        id: SurrealZodOptional<NormalizedFields<Name, Fields>["id"]>;
-    } : NormalizedFields<Name, Fields>) & Config["catchall"];
-    catchall?: SurrealZodType;
-    dto: Config["dto"];
+    fields: NormalizedFields<Name, Fields> & Config["catchall"];
+    catchall?: _core_.$ZodSurrealType;
     surreal: {
-        type: "table";
+        type?: undefined;
         tableType: "any" | "normal" | "relation";
         schemafull: boolean;
         drop: boolean;
         comment?: string;
     };
 }
-export interface SurrealZodTableInternals<Name extends string = string, Fields extends SurrealZodTableFields = {}, Config extends SurrealZodTableConfig = MergeConfig<SurrealZodTableConfig, SurrealZodTableConfigSchemaless>> extends SurrealZodTypeInternals {
+export interface ZodSurrealTableInternals<Name extends string = string, Fields extends SurrealZodTableFields = {}, Config extends SurrealZodTableConfig = MergeConfig<SurrealZodTableConfig, SurrealZodTableConfigSchemaless>> extends ZodSurrealTypeInternals<core.$InferObjectOutput<Fields, Config["catchall"]>, core.$InferObjectInput<Fields, Config["catchall"]>, _core_.$InferObjectDbOutput<Fields, Config["catchall"]>, _core_.$InferObjectDbInput<Fields, Config["catchall"]>> {
     def: SurrealZodTableDef<Name, Fields, Config>;
 }
-export interface SurrealZodTable<Name extends string = string, Fields extends SurrealZodTableFields = {}, Config extends SurrealZodTableConfig = MergeConfig<SurrealZodTableConfig, SurrealZodTableConfigSchemaless>> extends _SurrealZodType<SurrealZodTableInternals<Name, Fields, Config>> {
-    name<NewName extends string>(name: NewName): SurrealZodTable<NewName, Fields>;
-    fields<NewFields extends SurrealZodTableFields>(fields: NewFields): SurrealZodTable<Name, NewFields, Config>;
-    schemafull(): SurrealZodTable<Name, Fields, MergeConfig<Config, SurrealZodTableConfigSchemafull>>;
-    schemaless(): SurrealZodTable<Name, Fields, MergeConfig<Config, SurrealZodTableConfigSchemaless>>;
-    any(): SurrealZodTable<Name, Fields, Config>;
-    normal(): SurrealZodTableNormal<Name, Fields, Config>;
-    relation(): SurrealZodTableRelation<Name, SurrealZodRecordId<string, SurrealZodRecordIdValue>, SurrealZodRecordId<string, SurrealZodRecordIdValue>, Fields, Config>;
-    drop(): this;
-    nodrop(): this;
-    comment(comment: string): this;
-    record(): this["_zod"]["def"]["fields"]["id"];
-    dto(): SurrealZodTable<Name, Fields, MergeConfig<Config, SetConfig<"dto", true>>>;
-    entity(): SurrealZodTable<Name, Fields, MergeConfig<Config, SetConfig<"dto", false>>>;
+export type TableKind = "any" | "normal" | "relation";
+type RelationMethods<Name extends string, Fields extends SurrealZodTableFields, Config extends SurrealZodTableConfig> = {
+    from<NewFrom extends string | string[] | ZodSurrealdRecordId<string, ZodSurrealRecordIdValue>>(from: NewFrom): ZodSurrealTable<Name, Omit<Fields, "in"> & {
+        in: toRecordId<NewFrom>;
+    }, Config, "relation">;
+    to<NewTo extends string | string[] | ZodSurrealdRecordId<string, ZodSurrealRecordIdValue>>(to: NewTo): ZodSurrealTable<Name, Omit<Fields, "out"> & {
+        out: toRecordId<NewTo>;
+    }, Config, "relation">;
+    in: RelationMethods<Name, Fields, Config>["from"];
+    out: RelationMethods<Name, Fields, Config>["to"];
+};
+type MaybeRelationMethods<Kind extends TableKind, Name extends string, Fields extends SurrealZodTableFields, Config extends SurrealZodTableConfig> = Kind extends "relation" ? RelationMethods<Name, Fields, Config> : {};
+type TableMask<Keys extends PropertyKey, Kind extends TableKind> = {
+    [K in Exclude<Keys, "id" | (Kind extends "relation" ? "in" | "out" : never)>]?: true;
+} & {
+    id?: boolean;
+} & (Kind extends "relation" ? {
+    in?: boolean;
+    out?: boolean;
+} : {});
+export type ZodSurrealTable<Name extends string = string, Fields extends SurrealZodTableFields = {}, Config extends SurrealZodTableConfig = MergeConfig<SurrealZodTableConfig, SurrealZodTableConfigSchemaless>, Kind extends TableKind = "any"> = _core_.$ZodSurrealType<any, any, any, any, ZodSurrealTableInternals<Name, NormalizedFields<Name, Fields>, Config>> & MaybeRelationMethods<Kind, Name, Fields, Config> & ParsingEncodingDecodingMethods<ZodSurrealTable<Name, Fields, Config, Kind>> & {
+    clone(def?: ZodSurrealTableInternals<Name, NormalizedFields<Name, Fields>, Config>["def"], params?: {
+        parent: boolean;
+    }): ZodSurrealTable<Name, Fields, Config, Kind>;
+    register<R extends core.$ZodRegistry>(registry: R, ...meta: ZodSurrealTable<Name, Fields, Config, Kind> extends R["_schema"] ? undefined extends R["_meta"] ? [
+        core.$replace<R["_meta"], ZodSurrealTable<Name, Fields, Config, Kind>>?
+    ] : [
+        core.$replace<R["_meta"], ZodSurrealTable<Name, Fields, Config, Kind>>
+    ] : ["Incompatible schema"]): ZodSurrealTable<Name, Fields, Config, Kind>;
+    name<NewName extends string>(name: NewName): ZodSurrealTable<NewName, Fields, Config, Kind>;
+    fields<NewFields extends Kind extends "relation" ? SurrealZodTableRelationFields : SurrealZodTableFields>(fields: NewFields): ZodSurrealTable<Name, Kind extends "relation" ? {
+        [K in "in" | "out" as K extends keyof NewFields ? K : never]: NewFields[K];
+    } & {
+        [K in "in" | "out" as K extends keyof NewFields ? never : K extends keyof Fields ? K : never]: Fields[K];
+    } & Omit<NewFields, "in" | "out"> : NewFields, Config, Kind>;
+    schemafull(): ZodSurrealTable<Name, Fields, MergeConfig<Config, SurrealZodTableConfigSchemafull>, Kind>;
+    schemaless(): ZodSurrealTable<Name, Fields, MergeConfig<Config, SurrealZodTableConfigSchemaless>, Kind>;
+    any(): ZodSurrealTable<Name, Fields, Config, "any">;
+    normal(): ZodSurrealTable<Name, Fields, Config, "normal">;
+    relation(): ZodSurrealTable<Name, {
+        [K in "in" | "out"]: Fields[K] extends ZodSurrealdRecordId ? Fields[K] : ZodSurrealdRecordId<string, ZodSurrealRecordIdValue>;
+    } & Omit<Fields, "in" | "out">, Config, "relation">;
+    drop(): ZodSurrealTable<Name, Fields, Config, Kind>;
+    nodrop(): ZodSurrealTable<Name, Fields, Config, Kind>;
+    comment(comment: string): ZodSurrealTable<Name, Fields, Config, Kind>;
+    record(): ZodSurrealTable<Name, Fields, Config, Kind>["_zod"]["def"]["fields"]["id"];
+    dto(): ZodSurrealObject<Omit<NormalizedFields<Name, Fields>, "id"> & {
+        id: ZodSurrealOptional<NormalizedFields<Name, Fields>["id"]>;
+    }, {
+        in: Config["catchall"];
+        out: Config["catchall"];
+    }>;
+    table(): Table<Name>;
     toSurql(statement?: "define", options?: DefineTableOptions): BoundQuery<[undefined]>;
     toSurql(statement: "remove", options?: RemoveTableOptions): BoundQuery<[undefined]>;
     toSurql(statement: "info"): BoundQuery<[TableInfo]>;
     toSurql(statement: "structure"): BoundQuery<[TableStructure]>;
-}
-export declare const SurrealZodTable: core.$constructor<SurrealZodTable>;
-export declare function table<Name extends string = string>(name: Name): SurrealZodTable<Name>;
-export interface SurrealZodTableNormal<Name extends string = string, Fields extends SurrealZodTableFields = {}, Config extends SurrealZodTableConfig = MergeConfig<SurrealZodTableConfig, SurrealZodTableConfigSchemaless>> extends SurrealZodTable<Name, Fields, Config> {
-    name<NewName extends string>(name: NewName): SurrealZodTableNormal<NewName, Fields, Config>;
-    fields<NewFields extends SurrealZodTableFields>(fields: NewFields): SurrealZodTableNormal<Name, NewFields, Config>;
-    schemafull(): SurrealZodTableNormal<Name, Fields, MergeConfig<Config, SurrealZodTableConfigSchemafull>>;
-    schemaless(): SurrealZodTableNormal<Name, Fields, MergeConfig<Config, SurrealZodTableConfigSchemaless>>;
-    dto(): SurrealZodTableNormal<Name, Fields, MergeConfig<Config, SetConfig<"dto", true>>>;
-    entity(): SurrealZodTableNormal<Name, Fields, MergeConfig<Config, SetConfig<"dto", false>>>;
-}
-export declare const SurrealZodTableNormal: core.$constructor<SurrealZodTableNormal>;
-export declare function normalTable<Name extends string = string>(name: Name): SurrealZodTableNormal<Name>;
-export interface SurrealZodTableRelation<Name extends string = string, From extends SurrealZodRecordId<string, SurrealZodRecordIdValue> = SurrealZodRecordId<string, SurrealZodRecordIdValue>, To extends SurrealZodRecordId<string, SurrealZodRecordIdValue> = SurrealZodRecordId<string, SurrealZodRecordIdValue>, Fields extends SurrealZodTableFields = {}, Config extends SurrealZodTableConfig = MergeConfig<SurrealZodTableConfig, SurrealZodTableConfigSchemaless>> extends SurrealZodTable<Name, NormalizedIdField<inferRecordIdTable<To>, NormalizedIdField<inferRecordIdTable<From>, Fields & {
-    in: From;
-    out: To;
-}, "in">, "out">, Config> {
-    name<NewName extends string>(name: NewName): SurrealZodTableRelation<NewName, From, To, Fields, Config>;
-    fields<NewFields extends SurrealZodTableFields>(fields: NewFields): SurrealZodTableRelation<Name, From, To, NewFields, Config>;
-    schemafull(): SurrealZodTableRelation<Name, From, To, Fields, MergeConfig<Config, SurrealZodTableConfigSchemafull>>;
-    schemaless(): SurrealZodTableRelation<Name, From, To, Fields, MergeConfig<Config, SurrealZodTableConfigSchemaless>>;
-    from<NewFrom extends string | string[] | SurrealZodRecordId<string, SurrealZodRecordIdValue>>(from: NewFrom): SurrealZodTableRelation<Name extends string ? Name : Name[number], toRecordId<NewFrom>, To, Fields, MergeConfig<Config, SurrealZodTableConfigSchemafull>>;
-    to<NewTo extends string | string[] | SurrealZodRecordId<string, SurrealZodRecordIdValue>>(to: NewTo): SurrealZodTableRelation<Name extends string ? Name : Name[number], From, toRecordId<NewTo>, Fields, MergeConfig<Config, SurrealZodTableConfigSchemafull>>;
-    in<NewFrom extends string | string[] | SurrealZodRecordId<string, SurrealZodRecordIdValue>>(from: NewFrom): SurrealZodTableRelation<Name extends string ? Name : Name[number], toRecordId<NewFrom>, To, Fields, MergeConfig<Config, SurrealZodTableConfigSchemafull>>;
-    out<NewTo extends string | string[] | SurrealZodRecordId<string, SurrealZodRecordIdValue>>(to: NewTo): SurrealZodTableRelation<Name extends string ? Name : Name[number], From, toRecordId<NewTo>, Fields, MergeConfig<Config, SurrealZodTableConfigSchemafull>>;
-    dto(): SurrealZodTableRelation<Name, From, To, Fields, MergeConfig<Config, SetConfig<"dto", true>>>;
-    entity(): SurrealZodTableRelation<Name, From, To, Fields, MergeConfig<Config, SetConfig<"dto", false>>>;
-}
-type toRecordId<T extends string | string[] | SurrealZodRecordId<string, SurrealZodRecordIdValue>> = T extends string ? T extends SurrealZodRecordId<infer N, infer I> ? SurrealZodRecordId<N, I> : SurrealZodRecordId<T> : T extends string[] ? SurrealZodRecordId<T[number]> : T extends SurrealZodRecordId<string, SurrealZodRecordIdValue> ? T : never;
-export declare const SurrealZodTableRelation: core.$constructor<SurrealZodTableRelation>;
-export declare function relationTable<Name extends string = string>(name: Name): SurrealZodTableRelation<Name>;
-export interface SurrealZodOptionalDef<T extends SurrealZodType = SurrealZodType> extends core.$ZodOptionalDef<T> {
-    innerType: T;
-    surreal: {
-        type: "optional";
-    };
-}
-export interface SurrealZodOptionalInternals<T extends SurrealZodType = SurrealZodType> extends core.$ZodOptionalInternals<T> {
-    def: SurrealZodOptionalDef<T>;
-}
-export interface SurrealZodOptional<T extends SurrealZodType = SurrealZodType> extends _SurrealZodType<SurrealZodOptionalInternals<T>> {
-    unwrap(): T;
-}
-export declare const SurrealZodOptional: core.$constructor<SurrealZodOptional>;
-export declare function optional<T extends SurrealZodType = SurrealZodType>(innerType: T): SurrealZodOptional<T>;
-export interface SurrealZodNonOptionalDef<T extends SurrealZodType = SurrealZodType> extends core.$ZodNonOptionalDef<T> {
-    innerType: T;
-    surreal: {
-        type: "nonoptional";
-    };
-}
-export interface SurrealZodNonOptionalInternals<T extends SurrealZodType = SurrealZodType> extends core.$ZodNonOptionalInternals<T> {
-    def: SurrealZodNonOptionalDef<T>;
-}
-export interface SurrealZodNonOptional<T extends SurrealZodType = SurrealZodType> extends _SurrealZodType<SurrealZodNonOptionalInternals<T>> {
-}
-export declare const SurrealZodNonOptional: core.$constructor<SurrealZodNonOptional>;
-export declare function nonoptional<T extends SurrealZodType = SurrealZodType>(innerType: T): SurrealZodNonOptional<T>;
-export interface SurrealZodNullableDef<T extends SurrealZodType = SurrealZodType> extends core.$ZodNullableDef<T> {
-    innerType: T;
+    extend<ExtraFields extends Kind extends "relation" ? SurrealZodTableRelationFields : SurrealZodTableFields>(extraFields: ExtraFields): ZodSurrealTable<Name, core.util.Extend<Fields, ExtraFields>, Config, Kind>;
+    safeExtend<ExtraFields extends Kind extends "relation" ? SurrealZodTableRelationFields : SurrealZodTableFields>(shape: SafeExtendShape<Fields, ExtraFields> & Partial<Record<keyof Fields, core.SomeType>>): ZodSurrealTable<Name, core.util.Extend<Fields, ExtraFields>, Config, Kind>;
+    pick<M extends TableMask<keyof Fields, Kind>>(mask: M): M extends {
+        id: false;
+    } ? ZodSurrealObject<core.util.Flatten<Pick<Fields, Extract<Exclude<keyof Fields, "id">, keyof M>>>, {
+        out: Config["catchall"];
+        in: Config["catchall"];
+    }> : ZodSurrealTable<Name, core.util.Flatten<Pick<Fields, Extract<keyof Fields, keyof M | "id">>>, Config, Kind>;
+    omit<M extends TableMask<keyof Fields, Kind>>(mask: M): M extends {
+        id: true;
+    } ? ZodSurrealObject<core.util.Flatten<Omit<Fields, Extract<keyof Fields, keyof M>>>, {
+        in: Config["catchall"];
+        out: Config["catchall"];
+    }> : ZodSurrealTable<Name, core.util.Flatten<Omit<Fields, Extract<keyof Fields, keyof M>>>, Config, Kind>;
+    /**
+     * @returns a table schema that is partial for all fields, except for `id`
+     */
+    partial(): ZodSurrealTable<Name, {
+        [k in keyof Fields]: ZodSurrealOptional<Fields[k]>;
+    }, Config, Kind>;
+    /**
+     * @returns an object schema that is partial for all fields, including `id`.
+     * This is equivalent to calling `.dto().partial()`
+     */
+    partial(mask: true): ZodSurrealObject<core.util.Flatten<{
+        [k in keyof Fields | "id"]: k extends "id" ? Fields["id"] extends ZodSurrealdRecordId<infer N, infer I> ? ZodSurrealOptional<ZodSurrealdRecordId<N, I>> : ZodSurrealOptional<ZodSurrealdRecordId<Name, ZodSurrealRecordIdValue>> : ZodSurrealOptional<Fields[k]>;
+    }>, {
+        out: Config["catchall"];
+        in: Config["catchall"];
+    }>;
+    /**
+     * @returns an object schema that is partial for the fields specified in
+     * the mask, if id is specified in the mask, it will be marked as optional
+     * and an object schema will be returned instead of a table schema.
+     */
+    partial<M extends TableMask<keyof Fields, Kind>>(mask?: M): M extends {
+        id: true;
+    } ? ZodSurrealObject<core.util.Flatten<{
+        [k in keyof Fields | "id"]: k extends keyof M ? k extends "id" ? Fields["id"] extends ZodSurrealdRecordId<infer N, infer I, infer E> ? ZodSurrealOptional<ZodSurrealdRecordId<N, I, E>> : ZodSurrealOptional<ZodSurrealdRecordId<Name, ZodSurrealRecordIdValue>> : ZodSurrealOptional<Fields[k]> : Fields[k];
+    }>, {
+        out: Config["catchall"];
+        in: Config["catchall"];
+    }> : ZodSurrealTable<Name, {
+        [k in keyof Fields]: k extends keyof M ? ZodSurrealOptional<Fields[k]> : Fields[k];
+    }, Config, Kind>;
+    required(): ZodSurrealTable<Name, {
+        [k in keyof Fields]: ZodSurrealNonOptional<Fields[k]>;
+    }, Config, Kind>;
+    required<M extends core.util.Mask<keyof Fields>>(mask: M): ZodSurrealTable<Name, {
+        [k in keyof Fields]: k extends keyof M ? ZodSurrealNonOptional<Fields[k]> : Fields[k];
+    }, Config, Kind>;
+};
+export declare const ZodSurrealTable: core.$constructor<ZodSurrealTable>;
+export declare function table<Name extends string = string>(name: Name): ZodSurrealTable<Name>;
+export declare function normalTable<Name extends string = string>(name: Name): ZodSurrealTable<Name, {}, MergeConfig<SurrealZodTableConfig, SurrealZodTableConfigSchemaless>, "normal">;
+type toRecordId<T extends string | string[] | ZodSurrealdRecordId<string, ZodSurrealRecordIdValue>> = T extends string ? T extends ZodSurrealdRecordId<infer N, infer I> ? ZodSurrealdRecordId<N, I> : ZodSurrealdRecordId<T> : T extends string[] ? ZodSurrealdRecordId<T[number]> : T extends ZodSurrealdRecordId<string, ZodSurrealRecordIdValue> ? T : never;
+export interface ZodSurrealDurationDef extends ZodSurrealTypeDef {
+    type: "duration";
     surreal: {
-        type: "nullable";
+        type: "duration";
     };
 }
-export interface SurrealZodNullableInternals<T extends SurrealZodType = SurrealZodType> extends core.$ZodNullableInternals<T> {
-    def: SurrealZodNullableDef<T>;
+export interface ZodSurrealDurationInternals extends ZodSurrealTypeInternals<Duration, Duration> {
+    def: ZodSurrealDurationDef;
 }
-export interface SurrealZodNullable<T extends SurrealZodType = SurrealZodType> extends _SurrealZodType<SurrealZodNullableInternals<T>> {
+export interface ZodSurrealDuration extends _ZodSurrealType<ZodSurrealDurationInternals>, ZodSurrealFieldMethods {
 }
-export declare const SurrealZodNullable: core.$constructor<SurrealZodNullable>;
-export declare function nullable<T extends SurrealZodType = SurrealZodType>(innerType: T): SurrealZodNullable<T>;
-export declare function nullish<T extends SurrealZodType = SurrealZodType>(innerType: T): SurrealZodOptional<SurrealZodNullable<T>>;
-export type SurrealZodTypes = SurrealZodAny | SurrealZodUnknown | SurrealZodNever | SurrealZodUndefined | SurrealZodOptional | SurrealZodNonOptional | SurrealZodNull | SurrealZodNullable | SurrealZodBoolean | SurrealZodString | SurrealZodNumber | SurrealZodBigInt | SurrealZodObject | SurrealZodRecordId | SurrealZodTable;
+export declare const ZodSurrealDuration: core.$constructor<ZodSurrealDuration>;
+export declare function duration(): ZodSurrealDuration;
+export type ZodSurrealTypes = ZodSurrealString | ZodSurrealNumber | ZodSurrealBigInt | ZodSurrealBoolean | ZodSurrealDate | ZodSurrealSymbol | ZodSurrealUndefined | ZodSurrealNullable | ZodSurrealNull | ZodSurrealAny | ZodSurrealUnknown | ZodSurrealNever | ZodSurrealVoid | ZodSurrealArray | ZodSurrealObject | ZodSurrealUnion | ZodSurrealIntersection | ZodSurrealTuple | ZodSurrealRecord | ZodSurrealMap | ZodSurrealSet | ZodSurrealLiteral | ZodSurrealEnum | ZodSurrealFunction | ZodSurrealPromise | ZodSurrealLazy | ZodSurrealOptional | ZodSurrealDefault | ZodSurrealPrefault | ZodSurrealTemplateLiteral | ZodSurrealCustom | ZodSurrealTransform | ZodSurrealNonOptional | ZodSurrealReadonly | ZodSurrealNaN | ZodSurrealPipe | ZodSurrealSuccess | ZodSurrealCatch | ZodSurrealFile;