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

package/lib/zod/core.d.ts

@@ -0,0 +1,262 @@
+import * as core from "zod/v4/core";
+import type { ZodSurrealType } from "./schema";
+export type Params<T extends $ZodSurrealType | core.$ZodCheck, IssueTypes extends core.$ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = core.util.Flatten<Partial<core.util.EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
+    error?: string | core.$ZodErrorMap<IssueTypes> | undefined;
+    /** @deprecated This parameter is deprecated. Use `error` instead. */
+    message?: string | undefined;
+})>>>;
+export type TypeParams<T extends $ZodSurrealType = ZodSurrealType & {
+    _isst: never;
+}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+export interface $ZodSurrealTypeDef {
+    type: "string" | "number" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "any" | "unknown" | "never" | "void" | "date" | "array" | "object" | "union" | "intersection" | "tuple" | "record" | "map" | "set" | "enum" | "file" | "transform" | "literal" | "optional" | "nullable" | "default" | "prefault" | "nonoptional" | "success" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "lazy" | "promise" | "function" | "custom" | "record_id" | "table" | "field" | "duration";
+    error?: core.$ZodErrorMap<never> | undefined;
+    checks?: core.$ZodCheck<never>[];
+    surreal?: $ZodSurrealTypeDefInternals;
+}
+export interface $ZodSurrealTypeDefInternals {
+    type?: "string" | "number" | "int" | "float" | "bool" | "int" | "none" | "null" | "any" | "datetime" | "uuid" | "duration";
+}
+export interface _$ZodSurrealTypeInternals {
+    /** The `@zod/core` version of this schema */
+    version: typeof core.version;
+    /** Schema definition. */
+    def: $ZodSurrealTypeDef;
+    /** @internal Randomly generated ID for this schema. */
+    /** @internal List of deferred initializers. */
+    deferred: core.util.AnyFunc[] | undefined;
+    /** @internal Parses input and runs all checks (refinements). */
+    run(payload: core.ParsePayload<any>, ctx: core.ParseContextInternal): core.util.MaybeAsync<core.ParsePayload>;
+    /** @internal Parses input, doesn't run checks. */
+    parse(payload: core.ParsePayload<any>, ctx: core.ParseContextInternal): core.util.MaybeAsync<core.ParsePayload>;
+    /** @internal  Stores identifiers for the set of traits implemented by this schema. */
+    traits: Set<string>;
+    /** @internal Indicates that a schema output type should be considered optional inside objects.
+     * @default Required
+     */
+    /** @internal */
+    optin?: "optional" | undefined;
+    /** @internal */
+    optout?: "optional" | undefined;
+    /** @internal */
+    dboptin?: "optional" | undefined;
+    /** @internal */
+    dboptout?: "optional" | undefined;
+    /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
+     *
+     * Defined on: enum, const, literal, null, undefined
+     * Passthrough: optional, nullable, branded, default, catch, pipe
+     * Todo: unions?
+     */
+    values?: core.util.PrimitiveSet | undefined;
+    /** Default value bubbled up from  */
+    /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
+    propValues?: core.util.PropValues | undefined;
+    /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
+    pattern: RegExp | undefined;
+    /** @internal The constructor function of this schema. */
+    constr: new (def: any) => $ZodSurrealType;
+    /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
+    bag: Record<string, unknown>;
+    /** @internal The set of issues this schema might throw during type checking. */
+    isst: core.$ZodIssueBase;
+    /** @internal Subject to change, not a public API. */
+    processJSONSchema?: ((ctx: core.ToJSONSchemaContext, json: core.JSONSchema.BaseSchema, params: core.ProcessParams) => void) | undefined;
+    /** An optional method used to override `toJSONSchema` logic. */
+    toJSONSchema?: () => unknown;
+    /** @internal The parent of this schema. Only set during certain clone operations. */
+    parent?: $ZodSurrealType | undefined;
+}
+export interface $ZodSurrealTypeInternals<out O = unknown, out I = unknown, out DBO = O, out DBI = I> extends _$ZodSurrealTypeInternals {
+    /** @internal The inferred output type */
+    output: O;
+    /** @internal The inferred input type */
+    input: I;
+    /** @internal The inferred output type when using database context */
+    dboutput: DBO;
+    /** @internal The inferred input type when using database context */
+    dbinput: DBI;
+}
+export type $SomeSurrealType = {
+    _zod: _$ZodSurrealTypeInternals;
+};
+export type $ZodBranded<T extends $SomeSurrealType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
+    _zod: {
+        input: core.input<T> & core.$brand<Brand>;
+        output: core.output<T> & core.$brand<Brand>;
+    };
+} : Dir extends "in" ? {
+    _zod: {
+        input: core.input<T> & core.$brand<Brand>;
+    };
+} : {
+    _zod: {
+        output: core.output<T> & core.$brand<Brand>;
+    };
+});
+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.$ZodStandardSchema<this>;
+}
+export type $catchall<T extends $SomeSurrealType> = {
+    out: {
+        [k: string]: core.output<T>;
+    };
+    in: {
+        [k: string]: core.input<T>;
+    };
+};
+export type $ZodSurrealShape = Readonly<{
+    [k: string]: $ZodSurrealType;
+}>;
+export type OptionalOutSchema = {
+    _zod: {
+        optout: "optional";
+    };
+};
+export type OptionalDbOutSchema = {
+    _zod: {
+        dboptout: "optional";
+    };
+};
+export type OptionalInSchema = {
+    _zod: {
+        optin: "optional";
+    };
+};
+export type OptionalDbInSchema = {
+    _zod: {
+        dboptin: "optional";
+    };
+};
+export type IsOptionalIn<T extends $SomeSurrealType> = T extends OptionalInSchema ? true : false;
+export type IsOptionalOut<T extends $SomeSurrealType> = T extends OptionalOutSchema ? true : false;
+export type IsOptionalDbIn<T extends $SomeSurrealType> = T extends OptionalDbInSchema ? true : false;
+export type IsOptionalDbOut<T extends $SomeSurrealType> = T extends OptionalDbOutSchema ? true : false;
+export type $InferObjectDbOutput<T extends core.$ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? core.util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, dboutput<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : core.util.Prettify<{
+    -readonly [k in keyof T as T[k] extends OptionalDbOutSchema ? never : k]: T[k]["_zod"]["dboutput"];
+} & {
+    -readonly [k in keyof T as T[k] extends OptionalDbOutSchema ? k : never]?: T[k]["_zod"]["dboutput"];
+} & Extra>;
+export type $InferObjectDbInput<T extends core.$ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? core.util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, dbinput<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : core.util.Prettify<{
+    -readonly [k in keyof T as T[k] extends OptionalDbInSchema ? never : k]: T[k]["_zod"]["dbinput"];
+} & {
+    -readonly [k in keyof T as T[k] extends OptionalDbInSchema ? k : never]?: T[k]["_zod"]["dbinput"];
+} & Extra>;
+export type dbinput<T> = T extends {
+    _zod: {
+        dbinput: any;
+    };
+} ? T["_zod"]["dbinput"] : T extends {
+    _zod: {
+        input: any;
+    };
+} ? T["_zod"]["input"] : unknown;
+export type dboutput<T> = T extends {
+    _zod: {
+        dboutput: any;
+    };
+} ? T["_zod"]["dboutput"] : T extends {
+    _zod: {
+        output: any;
+    };
+} ? T["_zod"]["output"] : unknown;
+export type $InferUnionOutput<T extends $SomeSurrealType> = T extends any ? core.output<T> : never;
+export type $InferUnionInput<T extends $SomeSurrealType> = T extends any ? core.input<T> : never;
+export type $InferUnionDbOutput<T extends $SomeSurrealType> = T extends any ? dboutput<T> : never;
+export type $InferUnionDbInput<T extends $SomeSurrealType> = T extends any ? dbinput<T> : never;
+export interface $ZodSurrealTypeDiscriminableInternals extends $ZodSurrealTypeInternals {
+    propValues: core.util.PropValues;
+}
+export interface $ZodSurrealTypeDiscriminable extends $ZodSurrealType {
+    _zod: $ZodSurrealTypeDiscriminableInternals;
+}
+export type TupleItems = ReadonlyArray<$SomeSurrealType>;
+export type $InferTupleInputType<T extends TupleItems, Rest extends $SomeSurrealType | null> = [
+    ...TupleInputTypeWithOptionals<T>,
+    ...(Rest extends $SomeSurrealType ? core.input<Rest>[] : [])
+];
+type TupleInputTypeNoOptionals<T extends TupleItems> = {
+    [k in keyof T]: core.input<T[k]>;
+};
+type TupleInputTypeWithOptionals<T extends TupleItems> = T extends readonly [
+    ...infer Prefix extends $SomeSurrealType[],
+    infer Tail extends $SomeSurrealType
+] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, core.input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
+export type $InferTupleDbInputType<T extends TupleItems, Rest extends $SomeSurrealType | null> = [
+    ...TupleDbInputTypeWithOptionals<T>,
+    ...(Rest extends $SomeSurrealType ? dbinput<Rest>[] : [])
+];
+type TupleDbInputTypeNoOptionals<T extends TupleItems> = {
+    [k in keyof T]: dbinput<T[k]>;
+};
+type TupleDbInputTypeWithOptionals<T extends TupleItems> = T extends readonly [
+    ...infer Prefix extends $SomeSurrealType[],
+    infer Tail extends $SomeSurrealType
+] ? Tail["_zod"]["dboptin"] extends "optional" ? [...TupleDbInputTypeWithOptionals<Prefix>, dbinput<Tail>?] : TupleDbInputTypeNoOptionals<T> : [];
+export type $InferTupleOutputType<T extends TupleItems, Rest extends $SomeSurrealType | null> = [
+    ...TupleOutputTypeWithOptionals<T>,
+    ...(Rest extends $SomeSurrealType ? core.output<Rest>[] : [])
+];
+type TupleOutputTypeNoOptionals<T extends TupleItems> = {
+    [k in keyof T]: core.output<T[k]>;
+};
+type TupleOutputTypeWithOptionals<T extends TupleItems> = T extends readonly [
+    ...infer Prefix extends $SomeSurrealType[],
+    infer Tail extends $SomeSurrealType
+] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, core.output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
+export type $InferTupleDbOutputType<T extends TupleItems, Rest extends $SomeSurrealType | null> = [
+    ...TupleDbOutputTypeWithOptionals<T>,
+    ...(Rest extends $SomeSurrealType ? dboutput<Rest>[] : [])
+];
+type TupleDbOutputTypeNoOptionals<T extends TupleItems> = {
+    [k in keyof T]: dboutput<T[k]>;
+};
+type TupleDbOutputTypeWithOptionals<T extends TupleItems> = T extends readonly [
+    ...infer Prefix extends $SomeSurrealType[],
+    infer Tail extends $SomeSurrealType
+] ? Tail["_zod"]["dboptout"] extends "optional" ? [...TupleDbOutputTypeWithOptionals<Prefix>, dboutput<Tail>?] : TupleDbOutputTypeNoOptionals<T> : [];
+export type $ZodRecordKey = $ZodSurrealType<string | number | symbol, unknown>;
+export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $SomeSurrealType = $ZodSurrealType> = Key extends core.$partial ? Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;
+export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $SomeSurrealType = $ZodSurrealType> = Key extends core.$partial ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : Record<core.input<Key> & PropertyKey, core.input<Value>>;
+export type $InferZodRecordDbOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $SomeSurrealType = ZodSurrealType> = Key extends core.$partial ? Partial<Record<dboutput<Key>, dboutput<Value>>> : Record<dboutput<Key>, dboutput<Value>>;
+export type $InferZodRecordDbInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $SomeSurrealType = ZodSurrealType> = Key extends core.$partial ? Partial<Record<dbinput<Key> & PropertyKey, dbinput<Value>>> : Record<dbinput<Key> & PropertyKey, dbinput<Value>>;
+export type $InferEnumDbOutput<T extends core.util.EnumLike> = T[keyof T] & {};
+export type $InferEnumDbInput<T extends core.util.EnumLike> = T[keyof T] & {};
+export type ZodSurrealFunctionArgs = ZodSurrealType<unknown[], unknown[]>;
+export type ZodSurrealFunctionIn = ZodSurrealFunctionArgs;
+export type ZodSurrealFunctionOut = ZodSurrealType;
+export type $InferInnerFunctionType<Args extends ZodSurrealFunctionIn, Returns extends ZodSurrealFunctionOut> = (...args: ZodSurrealFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;
+export type $InferInnerFunctionDbType<Args extends ZodSurrealFunctionIn, Returns extends ZodSurrealFunctionOut> = (...args: ZodSurrealFunctionIn extends Args ? never[] : dboutput<Args>) => dbinput<Returns>;
+export type $InferInnerFunctionTypeAsync<Args extends ZodSurrealFunctionIn, Returns extends ZodSurrealFunctionOut> = (...args: ZodSurrealFunctionIn extends Args ? never[] : core.output<Args>) => core.util.MaybeAsync<core.input<Returns>>;
+export type $InferInnerFunctionDbTypeAsync<Args extends ZodSurrealFunctionIn, Returns extends ZodSurrealFunctionOut> = (...args: ZodSurrealFunctionIn extends Args ? never[] : dboutput<Args>) => core.util.MaybeAsync<dbinput<Returns>>;
+export type $InferOuterFunctionType<Args extends ZodSurrealFunctionIn, Returns extends ZodSurrealFunctionOut> = (...args: ZodSurrealFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;
+export type $InferOuterFunctionDbType<Args extends ZodSurrealFunctionIn, Returns extends ZodSurrealFunctionOut> = (...args: ZodSurrealFunctionIn extends Args ? never[] : dbinput<Args>) => dboutput<Returns>;
+export type $InferOuterFunctionTypeAsync<Args extends ZodSurrealFunctionIn, Returns extends ZodSurrealFunctionOut> = (...args: ZodSurrealFunctionIn extends Args ? never[] : core.input<Args>) => Promise<core.output<Returns>>;
+export type $InferOuterFunctionDbTypeAsync<Args extends ZodSurrealFunctionIn, Returns extends ZodSurrealFunctionOut> = (...args: ZodSurrealFunctionIn extends Args ? never[] : dbinput<Args>) => Promise<dboutput<Returns>>;
+export interface ZodSurrealFunctionDef<In extends ZodSurrealFunctionIn = ZodSurrealFunctionIn, Out extends ZodSurrealFunctionOut = ZodSurrealFunctionOut> extends $ZodSurrealTypeDef {
+    type: "function";
+    input: In;
+    output: Out;
+}
+type LiteralPart = Exclude<core.util.Literal, symbol>;
+interface SchemaPartInternals extends $ZodSurrealTypeInternals<LiteralPart, LiteralPart> {
+    pattern: RegExp;
+}
+interface SchemaPart extends $ZodSurrealType {
+    _zod: SchemaPartInternals;
+}
+export type $ZodSurrealTemplateLiteralPart = LiteralPart | SchemaPart;
+type UndefinedToEmptyString<T> = T extends undefined ? "" : T;
+type AppendToTemplateLiteral<Template extends string, Suffix extends LiteralPart | $ZodSurrealType> = Suffix extends LiteralPart ? `${Template}${UndefinedToEmptyString<Suffix>}` : Suffix extends $ZodSurrealType ? `${Template}${core.output<Suffix> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;
+export type $PartsToTemplateLiteral<Parts extends $ZodSurrealTemplateLiteralPart[]> = [] extends Parts ? `` : Parts extends [
+    ...infer Rest,
+    infer Last extends $ZodSurrealTemplateLiteralPart
+] ? Rest extends $ZodSurrealTemplateLiteralPart[] ? AppendToTemplateLiteral<$PartsToTemplateLiteral<Rest>, Last> : never : never;
+export declare function normalizeParams<T, S extends $ZodSurrealTypeDefInternals>(_params: T, surreal?: S): core.util.Normalize<T> & {
+    surreal: Exclude<S, undefined>;
+};
+export declare const clone: <T extends $ZodSurrealType>(inst: T, def?: T["_zod"]["def"], params?: {
+    parent: boolean;
+}) => T;
+export {};

package/lib/zod/core.js

@@ -0,0 +1,10 @@
+import * as core from "zod/v4/core";
+///////////////////////////// Type Overriden Functions /////////////////////////
+export function normalizeParams(_params, surreal) {
+    const params = core.util.normalizeParams(_params);
+    if (params && typeof params === "object") {
+        return { ...params, surreal: surreal ?? {} };
+    }
+    return params ?? { surreal: surreal ?? {} };
+}
+export const clone = core.clone;

package/lib/zod/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./parse";
+export * from "./schema";

package/lib/zod/index.js

@@ -0,0 +1,2 @@
+export * from "./parse";
+export * from "./schema";

package/lib/zod/json-schema.d.ts

@@ -0,0 +1,89 @@
+import * as core from "zod/v4/core";
+export declare const stringProcessor: core.Processor<core.$ZodString>;
+export declare const numberProcessor: core.Processor<core.$ZodNumber>;
+export declare const booleanProcessor: core.Processor<core.$ZodBoolean>;
+export declare const bigintProcessor: core.Processor<core.$ZodBigInt>;
+export declare const symbolProcessor: core.Processor<core.$ZodSymbol>;
+export declare const nullProcessor: core.Processor<core.$ZodNull>;
+export declare const undefinedProcessor: core.Processor<core.$ZodUndefined>;
+export declare const voidProcessor: core.Processor<core.$ZodVoid>;
+export declare const neverProcessor: core.Processor<core.$ZodNever>;
+export declare const anyProcessor: core.Processor<core.$ZodAny>;
+export declare const unknownProcessor: core.Processor<core.$ZodUnknown>;
+export declare const dateProcessor: core.Processor<core.$ZodDate>;
+export declare const enumProcessor: core.Processor<core.$ZodEnum>;
+export declare const literalProcessor: core.Processor<core.$ZodLiteral>;
+export declare const nanProcessor: core.Processor<core.$ZodNaN>;
+export declare const templateLiteralProcessor: core.Processor<core.$ZodTemplateLiteral>;
+export declare const fileProcessor: core.Processor<core.$ZodFile>;
+export declare const successProcessor: core.Processor<core.$ZodSuccess>;
+export declare const customProcessor: core.Processor<core.$ZodCustom>;
+export declare const functionProcessor: core.Processor<core.$ZodFunction>;
+export declare const transformProcessor: core.Processor<core.$ZodTransform>;
+export declare const mapProcessor: core.Processor<core.$ZodMap>;
+export declare const setProcessor: core.Processor<core.$ZodSet>;
+export declare const arrayProcessor: core.Processor<core.$ZodArray>;
+export declare const objectProcessor: core.Processor<core.$ZodObject>;
+export declare const unionProcessor: core.Processor<core.$ZodUnion>;
+export declare const intersectionProcessor: core.Processor<core.$ZodIntersection>;
+export declare const tupleProcessor: core.Processor<core.$ZodTuple>;
+export declare const recordProcessor: core.Processor<core.$ZodRecord>;
+export declare const nullableProcessor: core.Processor<core.$ZodNullable>;
+export declare const nonoptionalProcessor: core.Processor<core.$ZodNonOptional>;
+export declare const defaultProcessor: core.Processor<core.$ZodDefault>;
+export declare const prefaultProcessor: core.Processor<core.$ZodPrefault>;
+export declare const catchProcessor: core.Processor<core.$ZodCatch>;
+export declare const pipeProcessor: core.Processor<core.$ZodPipe>;
+export declare const readonlyProcessor: core.Processor<core.$ZodReadonly>;
+export declare const promiseProcessor: core.Processor<core.$ZodPromise>;
+export declare const optionalProcessor: core.Processor<core.$ZodOptional>;
+export declare const lazyProcessor: core.Processor<core.$ZodLazy>;
+export declare const allProcessors: {
+    string: core.Processor<core.$ZodString<unknown>>;
+    number: core.Processor<core.$ZodNumber<unknown>>;
+    boolean: core.Processor<core.$ZodBoolean<unknown>>;
+    bigint: core.Processor<core.$ZodBigInt<unknown>>;
+    symbol: core.Processor<core.$ZodSymbol>;
+    null: core.Processor<core.$ZodNull>;
+    undefined: core.Processor<core.$ZodUndefined>;
+    void: core.Processor<core.$ZodVoid>;
+    never: core.Processor<core.$ZodNever>;
+    any: core.Processor<core.$ZodAny>;
+    unknown: core.Processor<core.$ZodUnknown>;
+    date: core.Processor<core.$ZodDate<unknown>>;
+    enum: core.Processor<core.$ZodEnum<Readonly<Record<string, core.util.EnumValue>>>>;
+    literal: core.Processor<core.$ZodLiteral<core.util.Literal>>;
+    nan: core.Processor<core.$ZodNaN>;
+    template_literal: core.Processor<core.$ZodTemplateLiteral<string>>;
+    file: core.Processor<core.$ZodFile>;
+    success: core.Processor<core.$ZodSuccess<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    custom: core.Processor<core.$ZodCustom<unknown, unknown>>;
+    function: core.Processor<core.$ZodFunction<core.$ZodFunctionArgs, core.$ZodFunctionOut>>;
+    transform: core.Processor<core.$ZodTransform<unknown, unknown>>;
+    map: core.Processor<core.$ZodMap<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>, core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    set: core.Processor<core.$ZodSet<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    array: core.Processor<core.$ZodArray<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    object: core.Processor<core.$ZodObject<Readonly<Readonly<{
+        [k: string]: core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>;
+    }>>, core.$ZodObjectConfig>>;
+    union: core.Processor<core.$ZodUnion<readonly core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>[]>>;
+    intersection: core.Processor<core.$ZodIntersection<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>, core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    tuple: core.Processor<core.$ZodTuple<readonly core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>[], core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>> | null>>;
+    record: core.Processor<core.$ZodRecord<core.$ZodRecordKey, core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    nullable: core.Processor<core.$ZodNullable<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    nonoptional: core.Processor<core.$ZodNonOptional<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    default: core.Processor<core.$ZodDefault<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    prefault: core.Processor<core.$ZodPrefault<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    catch: core.Processor<core.$ZodCatch<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    pipe: core.Processor<core.$ZodPipe<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>, core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    readonly: core.Processor<core.$ZodReadonly<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    promise: core.Processor<core.$ZodPromise<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    optional: core.Processor<core.$ZodOptional<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+    lazy: core.Processor<core.$ZodLazy<core.$ZodType<unknown, unknown, core.$ZodTypeInternals<unknown, unknown>>>>;
+};
+export declare function toJSONSchema<T extends core.$ZodType>(schema: T, params?: core.ToJSONSchemaParams): core.ZodStandardJSONSchemaPayload<T>;
+export declare function toJSONSchema(registry: core.$ZodRegistry<{
+    id?: string | undefined;
+}>, params?: core.RegistryToJSONSchemaParams): {
+    schemas: Record<string, core.ZodStandardJSONSchemaPayload<core.$ZodType>>;
+};