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

package/lib/zod/schema.d.ts

@@ -0,0 +1,314 @@
+/** 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 * 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";
+}
+export interface SurrealZodInternals {
+    type: string;
+}
+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> {
+    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";
+        };
+    };
+}
+export interface SurrealZodAny extends _SurrealZodType<SurrealZodAnyInternals> {
+}
+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";
+        };
+    };
+}
+export interface SurrealZodUnknown extends _SurrealZodType<SurrealZodUnknownInternals> {
+}
+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 SurrealZodNever extends _SurrealZodType<SurrealZodNeverInternals> {
+}
+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 SurrealZodUndefined extends _SurrealZodType<SurrealZodUndefinedInternals> {
+}
+export declare const SurrealZodUndefined: core.$constructor<SurrealZodUndefined>;
+declare function _undefined(params?: string | core.$ZodUndefinedParams): SurrealZodUndefined;
+export { _undefined as undefined };
+export interface SurrealZodNullInternals extends core.$ZodNullInternals {
+    def: core.$ZodNullInternals["def"] & {
+        surreal: {
+            type: "null";
+        };
+    };
+}
+export interface SurrealZodNull extends _SurrealZodType<SurrealZodNullInternals> {
+}
+export declare const SurrealZodNull: core.$constructor<SurrealZodNull>;
+declare function _null(params?: string | core.$ZodNullParams): SurrealZodNull;
+export { _null as null };
+export interface SurrealZodBooleanInternals extends core.$ZodBooleanInternals {
+    def: core.$ZodBooleanInternals["def"] & {
+        surreal: {
+            type: "boolean";
+        };
+    };
+}
+export interface SurrealZodBoolean extends _SurrealZodType<SurrealZodBooleanInternals> {
+}
+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 SurrealZodString extends _SurrealZodType<SurrealZodStringInternals> {
+}
+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 SurrealZodNumber extends _SurrealZodType<SurrealZodNumberInternals> {
+}
+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 SurrealZodBigInt extends _SurrealZodType<SurrealZodBigIntInternals> {
+}
+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 SurrealZodObject<out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _SurrealZodType<SurrealZodObjectInternals<Shape, Config>> {
+    loose(): this;
+    /**
+     * @alias loose
+     */
+    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[];
+    surreal: {
+        type: "record_id";
+    };
+}
+export type RecordIdValueOutput<Id extends SurrealZodRecordIdValue> = 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 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 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;
+export type SurrealZodTableFields = {
+    [key: string]: SurrealZodType;
+};
+/**
+ * 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>;
+};
+export type NormalizedFields<TableName extends string = string, Fields extends SurrealZodTableFields = {}> = core.util.Prettify<NormalizedIdField<TableName, Fields, "id">>;
+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 = {
+    catchall: any;
+    dto: boolean;
+};
+export interface SurrealZodTableDef<Name extends string = string, Fields extends SurrealZodTableFields = {}, Config extends SurrealZodTableConfig = SurrealZodTableConfig> extends SurrealZodTypeDef {
+    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"];
+    surreal: {
+        type: "table";
+        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 {
+    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>>>;
+    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;
+    surreal: {
+        type: "nullable";
+    };
+}
+export interface SurrealZodNullableInternals<T extends SurrealZodType = SurrealZodType> extends core.$ZodNullableInternals<T> {
+    def: SurrealZodNullableDef<T>;
+}
+export interface SurrealZodNullable<T extends SurrealZodType = SurrealZodType> extends _SurrealZodType<SurrealZodNullableInternals<T>> {
+}
+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;