zod 4.2.0-canary.20251207T223211 → 4.2.0-canary.20251213T203150

package/v4/classic/schemas.d.ts

@@ -1,6 +1,8 @@
 import * as core from "../core/index.js";
 import { util } from "../core/index.js";
+import type { StandardSchemaWithJSONProps } from "../core/standard-schema.js";
 import * as parse from "./parse.js";
+export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
 export interface ZodType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
     def: Internals["def"];
     type: Internals["def"]["type"];
@@ -10,6 +12,9 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     _output: Internals["output"];
     /** @deprecated Use `z.input<typeof schema>` instead. */
     _input: Internals["input"];
+    "~standard": 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;
     clone(def?: Internals["def"], params?: {
         parent: boolean;
@@ -266,6 +271,7 @@ export declare const ZodJWT: core.$constructor<ZodJWT>;
 export declare function jwt(params?: string | core.$ZodJWTParams): ZodJWT;
 export interface ZodCustomStringFormat<Format extends string = string> extends ZodStringFormat<Format>, core.$ZodCustomStringFormat<Format> {
     _zod: core.$ZodCustomStringFormatInternals<Format>;
+    "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodCustomStringFormat: core.$constructor<ZodCustomStringFormat>;
 export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<Format>;
@@ -411,6 +417,7 @@ export interface ZodArray<T extends core.SomeType = core.$ZodType> extends _ZodT
     max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
     length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
     unwrap(): T;
+    "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodArray: core.$constructor<ZodArray>;
 export declare function array<T extends core.SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;
@@ -421,6 +428,7 @@ export type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLo
 export interface ZodObject<
 /** @ts-ignore Cast variance */
 out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _ZodType<core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     shape: Shape;
     keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
     /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
@@ -459,21 +467,25 @@ export declare function object<T extends core.$ZodLooseShape = Partial<Record<ne
 export declare function strictObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$strict>;
 export declare function looseObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$loose>;
 export interface ZodUnion<T extends readonly core.SomeType[] = readonly core.$ZodType[]> extends _ZodType<core.$ZodUnionInternals<T>>, core.$ZodUnion<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     options: T;
 }
 export declare const ZodUnion: core.$constructor<ZodUnion>;
 export declare function union<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$ZodUnionParams): ZodUnion<T>;
 export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[], Disc extends string = string> extends ZodUnion<Options>, core.$ZodDiscriminatedUnion<Options, Disc> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
     def: core.$ZodDiscriminatedUnionDef<Options, Disc>;
 }
 export declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;
 export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
 export interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodIntersectionInternals<A, B>>, core.$ZodIntersection<A, B> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodIntersection: core.$constructor<ZodIntersection>;
 export declare function intersection<T extends core.SomeType, U extends core.SomeType>(left: T, right: U): ZodIntersection<T, U>;
 export interface ZodTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends core.SomeType | null = core.$ZodType | null> extends _ZodType<core.$ZodTupleInternals<T, Rest>>, core.$ZodTuple<T, Rest> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     rest<Rest extends core.SomeType = core.$ZodType>(rest: Rest): ZodTuple<T, Rest>;
 }
 export declare const ZodTuple: core.$constructor<ZodTuple>;
@@ -481,6 +493,7 @@ export declare function tuple<T extends readonly [core.SomeType, ...core.SomeTyp
 export declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]], Rest extends core.SomeType>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodTuple<T, Rest>;
 export declare function tuple(items: [], params?: string | core.$ZodTupleParams): ZodTuple<[], null>;
 export interface ZodRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodRecordInternals<Key, Value>>, core.$ZodRecord<Key, Value> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     keyType: Key;
     valueType: Value;
 }
@@ -488,12 +501,14 @@ export declare const ZodRecord: core.$constructor<ZodRecord>;
 export declare function record<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key, Value>;
 export declare function partialRecord<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key & core.$partial, Value>;
 export interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodMapInternals<Key, Value>>, core.$ZodMap<Key, Value> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     keyType: Key;
     valueType: Value;
 }
 export declare const ZodMap: core.$constructor<ZodMap>;
 export declare function map<Key extends core.SomeType, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value>;
 export interface ZodSet<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodSetInternals<T>>, core.$ZodSet<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
     nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
     max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;
@@ -504,6 +519,7 @@ export declare function set<Value extends core.SomeType>(valueType: Value, param
 export interface ZodEnum<
 /** @ts-ignore Cast variance */
 out T extends util.EnumLike = util.EnumLike> extends _ZodType<core.$ZodEnumInternals<T>>, core.$ZodEnum<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     enum: T;
     options: Array<T[keyof T]>;
     extract<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Pick<T, U[number]>>>;
@@ -522,6 +538,7 @@ export { _enum as enum };
  */
 export declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T>;
 export interface ZodLiteral<T extends util.Literal = util.Literal> extends _ZodType<core.$ZodLiteralInternals<T>>, core.$ZodLiteral<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     values: Set<T>;
     /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
     value: T;
@@ -530,6 +547,7 @@ export declare const ZodLiteral: core.$constructor<ZodLiteral>;
 export declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number]>;
 export declare function literal<const T extends util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T>;
 export interface ZodFile extends _ZodType<core.$ZodFileInternals>, core.$ZodFile {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;
     max(size: number, params?: string | core.$ZodCheckMaxSizeParams): this;
     mime(types: util.MimeTypes | Array<util.MimeTypes>, params?: string | core.$ZodCheckMimeTypeParams): this;
@@ -537,21 +555,25 @@ export interface ZodFile extends _ZodType<core.$ZodFileInternals>, core.$ZodFile
 export declare const ZodFile: core.$constructor<ZodFile>;
 export declare function file(params?: string | core.$ZodFileParams): ZodFile;
 export interface ZodTransform<O = unknown, I = unknown> extends _ZodType<core.$ZodTransformInternals<O, I>>, core.$ZodTransform<O, I> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodTransform: core.$constructor<ZodTransform>;
 export declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): ZodTransform<Awaited<O>, I>;
 export interface ZodOptional<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodOptionalInternals<T>>, core.$ZodOptional<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
 }
 export declare const ZodOptional: core.$constructor<ZodOptional>;
 export declare function optional<T extends core.SomeType>(innerType: T): ZodOptional<T>;
 export interface ZodNullable<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodNullableInternals<T>>, core.$ZodNullable<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
 }
 export declare const ZodNullable: core.$constructor<ZodNullable>;
 export declare function nullable<T extends core.SomeType>(innerType: T): ZodNullable<T>;
 export declare function nullish<T extends core.SomeType>(innerType: T): ZodOptional<ZodNullable<T>>;
 export interface ZodDefault<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodDefaultInternals<T>>, core.$ZodDefault<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
     /** @deprecated Use `.unwrap()` instead. */
     removeDefault(): T;
@@ -559,21 +581,25 @@ export interface ZodDefault<T extends core.SomeType = core.$ZodType> extends _Zo
 export declare const ZodDefault: core.$constructor<ZodDefault>;
 export declare function _default<T extends core.SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodDefault<T>;
 export interface ZodPrefault<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodPrefaultInternals<T>>, core.$ZodPrefault<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
 }
 export declare const ZodPrefault: core.$constructor<ZodPrefault>;
 export declare function prefault<T extends core.SomeType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodPrefault<T>;
 export interface ZodNonOptional<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodNonOptionalInternals<T>>, core.$ZodNonOptional<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
 }
 export declare const ZodNonOptional: core.$constructor<ZodNonOptional>;
 export declare function nonoptional<T extends core.SomeType>(innerType: T, params?: string | core.$ZodNonOptionalParams): ZodNonOptional<T>;
 export interface ZodSuccess<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodSuccessInternals<T>>, core.$ZodSuccess<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
 }
 export declare const ZodSuccess: core.$constructor<ZodSuccess>;
 export declare function success<T extends core.SomeType>(innerType: T): ZodSuccess<T>;
 export interface ZodCatch<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodCatchInternals<T>>, core.$ZodCatch<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
     /** @deprecated Use `.unwrap()` instead. */
     removeCatch(): T;
@@ -582,16 +608,19 @@ export declare const ZodCatch: core.$constructor<ZodCatch>;
 declare function _catch<T extends core.SomeType>(innerType: T, catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)): ZodCatch<T>;
 export { _catch as catch };
 export interface ZodNaN extends _ZodType<core.$ZodNaNInternals>, core.$ZodNaN {
+    "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodNaN: core.$constructor<ZodNaN>;
 export declare function nan(params?: string | core.$ZodNaNParams): ZodNaN;
 export interface ZodPipe<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodPipeInternals<A, B>>, core.$ZodPipe<A, B> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     in: A;
     out: B;
 }
 export declare const ZodPipe: core.$constructor<ZodPipe>;
 export declare function pipe<const A extends core.SomeType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodPipe<A, B>;
 export interface ZodCodec<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends ZodPipe<A, B>, core.$ZodCodec<A, B> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     _zod: core.$ZodCodecInternals<A, B>;
     def: core.$ZodCodecDef<A, B>;
 }
@@ -601,25 +630,30 @@ export declare function codec<const A extends core.SomeType, B extends core.Some
     encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
 }): ZodCodec<A, B>;
 export interface ZodReadonly<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodReadonlyInternals<T>>, core.$ZodReadonly<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
 }
 export declare const ZodReadonly: core.$constructor<ZodReadonly>;
 export declare function readonly<T extends core.SomeType>(innerType: T): ZodReadonly<T>;
 export interface ZodTemplateLiteral<Template extends string = string> extends _ZodType<core.$ZodTemplateLiteralInternals<Template>>, core.$ZodTemplateLiteral<Template> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodTemplateLiteral: core.$constructor<ZodTemplateLiteral>;
 export declare function templateLiteral<const Parts extends core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | core.$ZodTemplateLiteralParams): ZodTemplateLiteral<core.$PartsToTemplateLiteral<Parts>>;
 export interface ZodLazy<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodLazyInternals<T>>, core.$ZodLazy<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
 }
 export declare const ZodLazy: core.$constructor<ZodLazy>;
 export declare function lazy<T extends core.SomeType>(getter: () => T): ZodLazy<T>;
 export interface ZodPromise<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodPromiseInternals<T>>, core.$ZodPromise<T> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     unwrap(): T;
 }
 export declare const ZodPromise: core.$constructor<ZodPromise>;
 export declare function promise<T extends core.SomeType>(innerType: T): ZodPromise<T>;
 export interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctionIn, Returns extends core.$ZodFunctionOut = core.$ZodFunctionOut> extends _ZodType<core.$ZodFunctionInternals<Args, Returns>>, core.$ZodFunction<Args, Returns> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
     _def: core.$ZodFunctionDef<Args, Returns>;
     _input: core.$InferInnerFunctionType<Args, Returns>;
     _output: core.$InferOuterFunctionType<Args, Returns>;
@@ -649,6 +683,7 @@ export declare function _function<In extends core.$ZodFunctionIn = core.$ZodFunc
 }): ZodFunction<In, Out>;
 export { _function as function };
 export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodCustomInternals<O, I>>, core.$ZodCustom<O, I> {
+    "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;

package/v4/classic/schemas.js

@@ -1,10 +1,19 @@
 import * as core from "../core/index.js";
 import { util } from "../core/index.js";
+import * as processors from "../core/json-schema-processors.js";
+import { createStandardJSONSchemaMethod, createToJSONSchemaMethod } from "../core/to-json-schema.js";
 import * as checks from "./checks.js";
 import * as iso from "./iso.js";
 import * as parse from "./parse.js";
 export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) => {
     core.$ZodType.init(inst, def);
+    Object.assign(inst["~standard"], {
+        jsonSchema: {
+            input: createStandardJSONSchemaMethod(inst, "input"),
+            output: createStandardJSONSchemaMethod(inst, "output"),
+        },
+    });
+    inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
     inst.def = def;
     inst.type = def.type;
     Object.defineProperty(inst, "_def", { value: def });
@@ -86,6 +95,7 @@ export const ZodType = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) =>
 export const _ZodString = /*@__PURE__*/ core.$constructor("_ZodString", (inst, def) => {
     core.$ZodString.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.stringProcessor(inst, ctx, json, params);
     const bag = inst._zod.bag;
     inst.format = bag.format ?? null;
     inst.minLength = bag.minimum ?? null;
@@ -348,6 +358,7 @@ export function hash(alg, params) {
 export const ZodNumber = /*@__PURE__*/ core.$constructor("ZodNumber", (inst, def) => {
     core.$ZodNumber.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.numberProcessor(inst, ctx, json, params);
     inst.gt = (value, params) => inst.check(checks.gt(value, params));
     inst.gte = (value, params) => inst.check(checks.gte(value, params));
     inst.min = (value, params) => inst.check(checks.gte(value, params));
@@ -398,6 +409,7 @@ export function uint32(params) {
 export const ZodBoolean = /*@__PURE__*/ core.$constructor("ZodBoolean", (inst, def) => {
     core.$ZodBoolean.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.booleanProcessor(inst, ctx, json, params);
 });
 export function boolean(params) {
     return core._boolean(ZodBoolean, params);
@@ -405,6 +417,7 @@ export function boolean(params) {
 export const ZodBigInt = /*@__PURE__*/ core.$constructor("ZodBigInt", (inst, def) => {
     core.$ZodBigInt.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.bigintProcessor(inst, ctx, json, params);
     inst.gte = (value, params) => inst.check(checks.gte(value, params));
     inst.min = (value, params) => inst.check(checks.gte(value, params));
     inst.gt = (value, params) => inst.check(checks.gt(value, params));
@@ -441,6 +454,7 @@ export function uint64(params) {
 export const ZodSymbol = /*@__PURE__*/ core.$constructor("ZodSymbol", (inst, def) => {
     core.$ZodSymbol.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.symbolProcessor(inst, ctx, json, params);
 });
 export function symbol(params) {
     return core._symbol(ZodSymbol, params);
@@ -448,6 +462,7 @@ export function symbol(params) {
 export const ZodUndefined = /*@__PURE__*/ core.$constructor("ZodUndefined", (inst, def) => {
     core.$ZodUndefined.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.undefinedProcessor(inst, ctx, json, params);
 });
 function _undefined(params) {
     return core._undefined(ZodUndefined, params);
@@ -456,6 +471,7 @@ export { _undefined as undefined };
 export const ZodNull = /*@__PURE__*/ core.$constructor("ZodNull", (inst, def) => {
     core.$ZodNull.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.nullProcessor(inst, ctx, json, params);
 });
 function _null(params) {
     return core._null(ZodNull, params);
@@ -464,6 +480,7 @@ export { _null as null };
 export const ZodAny = /*@__PURE__*/ core.$constructor("ZodAny", (inst, def) => {
     core.$ZodAny.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.anyProcessor(inst, ctx, json, params);
 });
 export function any() {
     return core._any(ZodAny);
@@ -471,6 +488,7 @@ export function any() {
 export const ZodUnknown = /*@__PURE__*/ core.$constructor("ZodUnknown", (inst, def) => {
     core.$ZodUnknown.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.unknownProcessor(inst, ctx, json, params);
 });
 export function unknown() {
     return core._unknown(ZodUnknown);
@@ -478,6 +496,7 @@ export function unknown() {
 export const ZodNever = /*@__PURE__*/ core.$constructor("ZodNever", (inst, def) => {
     core.$ZodNever.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.neverProcessor(inst, ctx, json, params);
 });
 export function never(params) {
     return core._never(ZodNever, params);
@@ -485,6 +504,7 @@ export function never(params) {
 export const ZodVoid = /*@__PURE__*/ core.$constructor("ZodVoid", (inst, def) => {
     core.$ZodVoid.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.voidProcessor(inst, ctx, json, params);
 });
 function _void(params) {
     return core._void(ZodVoid, params);
@@ -493,6 +513,7 @@ export { _void as void };
 export const ZodDate = /*@__PURE__*/ core.$constructor("ZodDate", (inst, def) => {
     core.$ZodDate.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.dateProcessor(inst, ctx, json, params);
     inst.min = (value, params) => inst.check(checks.gte(value, params));
     inst.max = (value, params) => inst.check(checks.lte(value, params));
     const c = inst._zod.bag;
@@ -505,6 +526,7 @@ export function date(params) {
 export const ZodArray = /*@__PURE__*/ core.$constructor("ZodArray", (inst, def) => {
     core.$ZodArray.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.arrayProcessor(inst, ctx, json, params);
     inst.element = def.element;
     inst.min = (minLength, params) => inst.check(checks.minLength(minLength, params));
     inst.nonempty = (params) => inst.check(checks.minLength(1, params));
@@ -523,6 +545,7 @@ export function keyof(schema) {
 export const ZodObject = /*@__PURE__*/ core.$constructor("ZodObject", (inst, def) => {
     core.$ZodObjectJIT.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.objectProcessor(inst, ctx, json, params);
     util.defineLazy(inst, "shape", () => {
         return def.shape;
     });
@@ -573,6 +596,7 @@ export function looseObject(shape, params) {
 export const ZodUnion = /*@__PURE__*/ core.$constructor("ZodUnion", (inst, def) => {
     core.$ZodUnion.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.unionProcessor(inst, ctx, json, params);
     inst.options = def.options;
 });
 export function union(options, params) {
@@ -598,6 +622,7 @@ export function discriminatedUnion(discriminator, options, params) {
 export const ZodIntersection = /*@__PURE__*/ core.$constructor("ZodIntersection", (inst, def) => {
     core.$ZodIntersection.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.intersectionProcessor(inst, ctx, json, params);
 });
 export function intersection(left, right) {
     return new ZodIntersection({
@@ -609,6 +634,7 @@ export function intersection(left, right) {
 export const ZodTuple = /*@__PURE__*/ core.$constructor("ZodTuple", (inst, def) => {
     core.$ZodTuple.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.tupleProcessor(inst, ctx, json, params);
     inst.rest = (rest) => inst.clone({
         ...inst._zod.def,
         rest: rest,
@@ -628,6 +654,7 @@ export function tuple(items, _paramsOrRest, _params) {
 export const ZodRecord = /*@__PURE__*/ core.$constructor("ZodRecord", (inst, def) => {
     core.$ZodRecord.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.recordProcessor(inst, ctx, json, params);
     inst.keyType = def.keyType;
     inst.valueType = def.valueType;
 });
@@ -653,6 +680,7 @@ export function partialRecord(keyType, valueType, params) {
 export const ZodMap = /*@__PURE__*/ core.$constructor("ZodMap", (inst, def) => {
     core.$ZodMap.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.mapProcessor(inst, ctx, json, params);
     inst.keyType = def.keyType;
     inst.valueType = def.valueType;
 });
@@ -667,6 +695,7 @@ export function map(keyType, valueType, params) {
 export const ZodSet = /*@__PURE__*/ core.$constructor("ZodSet", (inst, def) => {
     core.$ZodSet.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.setProcessor(inst, ctx, json, params);
     inst.min = (...args) => inst.check(core._minSize(...args));
     inst.nonempty = (params) => inst.check(core._minSize(1, params));
     inst.max = (...args) => inst.check(core._maxSize(...args));
@@ -682,6 +711,7 @@ export function set(valueType, params) {
 export const ZodEnum = /*@__PURE__*/ core.$constructor("ZodEnum", (inst, def) => {
     core.$ZodEnum.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.enumProcessor(inst, ctx, json, params);
     inst.enum = def.entries;
     inst.options = Object.values(def.entries);
     const keys = new Set(Object.keys(def.entries));
@@ -744,6 +774,7 @@ export function nativeEnum(entries, params) {
 export const ZodLiteral = /*@__PURE__*/ core.$constructor("ZodLiteral", (inst, def) => {
     core.$ZodLiteral.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.literalProcessor(inst, ctx, json, params);
     inst.values = new Set(def.values);
     Object.defineProperty(inst, "value", {
         get() {
@@ -764,6 +795,7 @@ export function literal(value, params) {
 export const ZodFile = /*@__PURE__*/ core.$constructor("ZodFile", (inst, def) => {
     core.$ZodFile.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.fileProcessor(inst, ctx, json, params);
     inst.min = (size, params) => inst.check(core._minSize(size, params));
     inst.max = (size, params) => inst.check(core._maxSize(size, params));
     inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));
@@ -774,6 +806,7 @@ export function file(params) {
 export const ZodTransform = /*@__PURE__*/ core.$constructor("ZodTransform", (inst, def) => {
     core.$ZodTransform.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.transformProcessor(inst, ctx, json, params);
     inst._zod.parse = (payload, _ctx) => {
         if (_ctx.direction === "backward") {
             throw new core.$ZodEncodeError(inst.constructor.name);
@@ -814,6 +847,7 @@ export function transform(fn) {
 export const ZodOptional = /*@__PURE__*/ core.$constructor("ZodOptional", (inst, def) => {
     core.$ZodOptional.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.optionalProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 export function optional(innerType) {
@@ -825,6 +859,7 @@ export function optional(innerType) {
 export const ZodNullable = /*@__PURE__*/ core.$constructor("ZodNullable", (inst, def) => {
     core.$ZodNullable.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.nullableProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 export function nullable(innerType) {
@@ -840,6 +875,7 @@ export function nullish(innerType) {
 export const ZodDefault = /*@__PURE__*/ core.$constructor("ZodDefault", (inst, def) => {
     core.$ZodDefault.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.defaultProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
     inst.removeDefault = inst.unwrap;
 });
@@ -855,6 +891,7 @@ export function _default(innerType, defaultValue) {
 export const ZodPrefault = /*@__PURE__*/ core.$constructor("ZodPrefault", (inst, def) => {
     core.$ZodPrefault.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.prefaultProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 export function prefault(innerType, defaultValue) {
@@ -869,6 +906,7 @@ export function prefault(innerType, defaultValue) {
 export const ZodNonOptional = /*@__PURE__*/ core.$constructor("ZodNonOptional", (inst, def) => {
     core.$ZodNonOptional.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.nonoptionalProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 export function nonoptional(innerType, params) {
@@ -881,6 +919,7 @@ export function nonoptional(innerType, params) {
 export const ZodSuccess = /*@__PURE__*/ core.$constructor("ZodSuccess", (inst, def) => {
     core.$ZodSuccess.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.successProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 export function success(innerType) {
@@ -892,6 +931,7 @@ export function success(innerType) {
 export const ZodCatch = /*@__PURE__*/ core.$constructor("ZodCatch", (inst, def) => {
     core.$ZodCatch.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.catchProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
     inst.removeCatch = inst.unwrap;
 });
@@ -906,6 +946,7 @@ export { _catch as catch };
 export const ZodNaN = /*@__PURE__*/ core.$constructor("ZodNaN", (inst, def) => {
     core.$ZodNaN.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.nanProcessor(inst, ctx, json, params);
 });
 export function nan(params) {
     return core._nan(ZodNaN, params);
@@ -913,6 +954,7 @@ export function nan(params) {
 export const ZodPipe = /*@__PURE__*/ core.$constructor("ZodPipe", (inst, def) => {
     core.$ZodPipe.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.pipeProcessor(inst, ctx, json, params);
     inst.in = def.in;
     inst.out = def.out;
 });
@@ -940,6 +982,7 @@ export function codec(in_, out, params) {
 export const ZodReadonly = /*@__PURE__*/ core.$constructor("ZodReadonly", (inst, def) => {
     core.$ZodReadonly.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.readonlyProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 export function readonly(innerType) {
@@ -951,6 +994,7 @@ export function readonly(innerType) {
 export const ZodTemplateLiteral = /*@__PURE__*/ core.$constructor("ZodTemplateLiteral", (inst, def) => {
     core.$ZodTemplateLiteral.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.templateLiteralProcessor(inst, ctx, json, params);
 });
 export function templateLiteral(parts, params) {
     return new ZodTemplateLiteral({
@@ -962,6 +1006,7 @@ export function templateLiteral(parts, params) {
 export const ZodLazy = /*@__PURE__*/ core.$constructor("ZodLazy", (inst, def) => {
     core.$ZodLazy.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.lazyProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.getter();
 });
 export function lazy(getter) {
@@ -973,6 +1018,7 @@ export function lazy(getter) {
 export const ZodPromise = /*@__PURE__*/ core.$constructor("ZodPromise", (inst, def) => {
     core.$ZodPromise.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.promiseProcessor(inst, ctx, json, params);
     inst.unwrap = () => inst._zod.def.innerType;
 });
 export function promise(innerType) {
@@ -984,6 +1030,7 @@ export function promise(innerType) {
 export const ZodFunction = /*@__PURE__*/ core.$constructor("ZodFunction", (inst, def) => {
     core.$ZodFunction.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.functionProcessor(inst, ctx, json, params);
 });
 export function _function(params) {
     return new ZodFunction({
@@ -996,6 +1043,7 @@ export { _function as function };
 export const ZodCustom = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def) => {
     core.$ZodCustom.init(inst, def);
     ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);
 });
 // custom checks
 export function check(fn) {

package/v4/core/index.cjs

@@ -26,7 +26,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONSchema = exports.locales = exports.regexes = exports.util = void 0;
+exports.JSONSchema = exports.JSONSchemaGenerator = exports.toJSONSchema = exports.locales = exports.regexes = exports.util = void 0;
 __exportStar(require("./core.cjs"), exports);
 __exportStar(require("./parse.cjs"), exports);
 __exportStar(require("./errors.cjs"), exports);
@@ -40,4 +40,8 @@ __exportStar(require("./registries.cjs"), exports);
 __exportStar(require("./doc.cjs"), exports);
 __exportStar(require("./api.cjs"), exports);
 __exportStar(require("./to-json-schema.cjs"), exports);
+var json_schema_processors_js_1 = require("./json-schema-processors.cjs");
+Object.defineProperty(exports, "toJSONSchema", { enumerable: true, get: function () { return json_schema_processors_js_1.toJSONSchema; } });
+var json_schema_generator_js_1 = require("./json-schema-generator.cjs");
+Object.defineProperty(exports, "JSONSchemaGenerator", { enumerable: true, get: function () { return json_schema_generator_js_1.JSONSchemaGenerator; } });
 exports.JSONSchema = __importStar(require("./json-schema.cjs"));

package/v4/core/index.d.cts

@@ -11,4 +11,6 @@ export * from "./registries.cjs";
 export * from "./doc.cjs";
 export * from "./api.cjs";
 export * from "./to-json-schema.cjs";
+export { toJSONSchema } from "./json-schema-processors.cjs";
+export { JSONSchemaGenerator } from "./json-schema-generator.cjs";
 export * as JSONSchema from "./json-schema.cjs";

package/v4/core/index.d.ts

@@ -11,4 +11,6 @@ export * from "./registries.js";
 export * from "./doc.js";
 export * from "./api.js";
 export * from "./to-json-schema.js";
+export { toJSONSchema } from "./json-schema-processors.js";
+export { JSONSchemaGenerator } from "./json-schema-generator.js";
 export * as JSONSchema from "./json-schema.js";

package/v4/core/index.js

@@ -11,4 +11,6 @@ export * from "./registries.js";
 export * from "./doc.js";
 export * from "./api.js";
 export * from "./to-json-schema.js";
+export { toJSONSchema } from "./json-schema-processors.js";
+export { JSONSchemaGenerator } from "./json-schema-generator.js";
 export * as JSONSchema from "./json-schema.js";