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

package/lib/zod/original.js

@@ -0,0 +1,177 @@
+/** biome-ignore-all assist/source/organizeImports: re-exporting */
+export { 
+// iso
+iso, ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, 
+// email
+email, ZodEmail, 
+// // guid (patched)
+guid as originalGuid, ZodGUID as OriginalZodGUID, 
+// // uuid (patched)
+uuid as originalUuid, ZodUUID as OriginalZodUUID, 
+// uuidv4 (patched)
+uuidv4 as originalUuidv4, 
+// // uuidv6 (patched)
+uuidv6 as originalUuidv6, 
+// // uuidv7 (patched)
+uuidv7 as originalUuidv7, 
+// url
+url, ZodURL, 
+// httpUrl
+httpUrl, 
+// emoji
+emoji, ZodEmoji, 
+// nanoid
+nanoid, ZodNanoID, 
+// cuid
+cuid, ZodCUID, 
+// cuid2
+cuid2, ZodCUID2, 
+// ulid
+ulid, ZodULID, 
+// xid
+xid, ZodXID, 
+// ksuid
+ksuid, ZodKSUID, 
+// ipv4
+ipv4, ZodIPv4, 
+// mac
+mac, ZodMAC, 
+// ipv6
+ipv6, ZodIPv6, 
+// cidrv4
+cidrv4, ZodCIDRv4, 
+// cidrv6
+cidrv6, ZodCIDRv6, 
+// base64
+base64, ZodBase64, 
+// base64url
+base64url, ZodBase64URL, 
+// e164
+e164, ZodE164, 
+// jwt
+jwt, ZodJWT, 
+// stringFormat
+stringFormat, ZodStringFormat, ZodCustomStringFormat, 
+// hostname
+hostname, 
+// hex
+hex, 
+// hash
+hash, 
+// number
+number, ZodNumber, ZodNumberFormat, 
+// int
+int, 
+// float32
+float32, 
+// float64
+float64, 
+// int32
+int32, 
+// uint32
+uint32, 
+// boolean
+boolean, ZodBoolean, 
+// bigint
+bigint, ZodBigInt, ZodBigIntFormat, 
+// int64
+int64, 
+// uint64
+uint64, 
+// symbol
+symbol, ZodSymbol, 
+// undefined
+undefined, ZodUndefined, 
+// any
+any, ZodAny, 
+// unknown
+unknown, ZodUnknown, 
+// never
+never, ZodNever, 
+// void
+void, ZodVoid, 
+// null
+null, ZodNull, 
+// date (patched)
+date as originalDate, ZodDate as OriginalZodDate, 
+// array
+array, ZodArray, 
+// keyof
+keyof, 
+// object
+object, ZodObject, 
+// strictObject
+strictObject, 
+// looseObject
+looseObject, 
+// union
+union, ZodUnion, 
+// discriminatedUnion
+discriminatedUnion, ZodDiscriminatedUnion, 
+// intersection
+intersection, ZodIntersection, 
+// tuple
+// tuple,
+// ZodTuple,
+// record
+record, ZodRecord, 
+// partialRecord
+partialRecord, 
+// map
+map, ZodMap, 
+// set
+set, ZodSet, 
+// enum
+enum, ZodEnum, 
+// nativeEnum
+nativeEnum, 
+// literal
+literal, ZodLiteral, 
+// file
+file, ZodFile, 
+// transform
+transform, ZodTransform, 
+// optional
+optional, ZodOptional, 
+// nullable
+nullable, ZodNullable, 
+// nullish
+nullish, 
+// default
+_default, ZodDefault, 
+// prefault
+prefault, ZodPrefault, 
+// nonoptional
+nonoptional, ZodNonOptional, 
+// success
+success, ZodSuccess, 
+// catch
+catch, ZodCatch, 
+// nan
+nan, ZodNaN, 
+// pipe
+pipe, ZodPipe, 
+// codec
+codec, ZodCodec, 
+// readonly
+readonly, ZodReadonly, 
+// templateLiteral
+templateLiteral, ZodTemplateLiteral, 
+// lazy
+lazy, ZodLazy, 
+// promise
+promise, ZodPromise, 
+// function
+function, _function, ZodFunction, 
+// custom
+custom, ZodCustom, 
+//
+//      Others
+//
+clone, coerce, check, 
+// Error
+ZodError, ZodRealError, formatError, getErrorMap, setErrorMap, 
+// Safe
+decode, decodeAsync, safeDecode, safeDecodeAsync, encode, encodeAsync, safeEncode, safeEncodeAsync, parse, parseAsync, safeParse, safeParseAsync, $output, $input, $brand, meta, 
+//
+ZodFirstPartyTypeKind, NEVER, ZodType, TimePrecision, config, core, endsWith, startsWith, describe, flattenError, globalRegistry, gt, gte, lt, lte, includes, instanceof, json, length, locales, lowercase, toLowerCase, uppercase, toUpperCase, minLength, maxLength, minSize, maxSize, size, multipleOf, negative, nonnegative, positive, nonpositive, property, normalize, overwrite, preprocess, prettifyError, refine, superRefine, regexes, mime, regex, slugify, stringbool, trim, registry, toJSONSchema, treeifyError, util, z, ZodIssueCode, } from "zod/v4";

package/lib/zod/parse.d.ts

@@ -0,0 +1,71 @@
+import type { Surreal, SurrealTransaction } from "surrealdb";
+import * as classic from "zod/v4";
+import * as core from "zod/v4/core";
+import type * as _core_ from "./core";
+import type { ZodSurrealType } from "./schema";
+export interface ParseDbContext<T extends core.$ZodIssueBase = core.$ZodIssue> extends core.ParseContext<T> {
+    db?: Surreal | SurrealTransaction;
+}
+export interface ParseDbContextInternal<T extends core.$ZodIssueBase = core.$ZodIssue> extends core.ParseContextInternal<T> {
+    db?: Surreal | SurrealTransaction;
+}
+export type ZodSafeParseResult<T> = classic.ZodSafeParseSuccess<T> | classic.ZodSafeParseError<T>;
+export type ParsingEncodingDecodingMethodNames = "parse" | "encode" | "decode" | "parseAsync" | "encodeAsync" | "decodeAsync" | "safeParse" | "safeEncode" | "safeDecode" | "safeParseAsync" | "safeEncodeAsync" | "safeDecodeAsync";
+export interface ParsingEncodingDecodingMethods<T extends _core_.$SomeSurrealType> {
+    parse<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>;
+    encode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>, params?: Ctx): Ctx extends {
+        db: any;
+    } ? _core_.dbinput<T> : core.input<T>;
+    decode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<T> : core.input<T>, params?: Ctx): Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>;
+    parseAsync<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Promise<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>>;
+    encodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>, params?: Ctx): Promise<Ctx extends {
+        db: any;
+    } ? _core_.dbinput<T> : core.input<T>>;
+    decodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<T> : core.input<T>, params?: Ctx): Promise<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>>;
+    safeParse<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>>;
+    safeEncode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>, params?: Ctx): classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dbinput<T> : core.input<T>>;
+    safeDecode<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<T> : core.input<T>, params?: Ctx): classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>>;
+    safeParseAsync<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>>>;
+    spa<Ctx extends ParseDbContext>(data: unknown, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>>>;
+    safeEncodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dbinput<T> : core.input<T>>>;
+    safeDecodeAsync<Ctx extends ParseDbContext>(data: Ctx extends {
+        db: any;
+    } ? _core_.dbinput<T> : core.input<T>, params?: Ctx): Promise<classic.ZodSafeParseResult<Ctx extends {
+        db: any;
+    } ? _core_.dboutput<T> : core.output<T>>>;
+}
+export declare function assignParsingMethods(inst: ZodSurrealType): void;

package/lib/zod/parse.js

@@ -0,0 +1,17 @@
+import * as classic from "zod/v4";
+import * as core from "zod/v4/core";
+export function assignParsingMethods(inst) {
+    inst.parse = (data, params) => classic.parse(inst, data, params);
+    inst.decode = (data, params) => classic.decode(inst, data, params);
+    inst.encode = (data, params) => classic.encode(inst, data, params);
+    inst.parseAsync = (data, params) => classic.parseAsync(inst, data, params);
+    inst.decodeAsync = (data, params) => classic.decodeAsync(inst, data, params);
+    inst.encodeAsync = (data, params) => classic.encodeAsync(inst, data, params);
+    inst.safeParse = (data, params) => classic.safeParse(inst, data, params);
+    inst.safeDecode = (data, params) => classic.safeDecode(inst, data, params);
+    inst.safeEncode = (data, params) => classic.safeEncode(inst, data, params);
+    inst.safeParseAsync = (data, params) => classic.safeParseAsync(inst, data, params);
+    inst.spa = inst.safeParseAsync;
+    inst.safeDecodeAsync = (data, params) => classic.safeDecodeAsync(inst, data, params);
+    inst.safeEncodeAsync = (data, params) => classic.safeEncodeAsync(inst, data, params);
+}