z.ZodSchema

import { z } from "https://esm.sh/zod@3.25.76/index.d.cts"; 

const { ZodSchema } = z;

abstract

abstract class ZodSchema<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {

constructor(def: Def);

readonly _def: Def;

readonly _input: Input;

readonly _output: Output;

readonly _type: Output;

~standard: StandardSchemaV1.Props<Input, Output>;

get description(): string | undefined;

spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;

_getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;

_getType(input: ParseInput): string;

abstract _parse(input: ParseInput): ParseReturnType<Output>;

_parseAsync(input: ParseInput): AsyncParseReturnType<Output>;

_parseSync(input: ParseInput): SyncParseReturnType<Output>;

_processInputParams(input: ParseInput): {

status: ParseStatus;

ctx: ParseContext;

};

_refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;

~validate(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;

and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;

array(): ZodArray<this>;

brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;

catch(def: Output): ZodCatch<this>;

catch(def: (ctx: {

error: ZodError;

input: Input;

}) => Output): ZodCatch<this>;

default(def: util.noUndefined<Input>): ZodDefault<this>;

default(def: () => util.noUndefined<Input>): ZodDefault<this>;

describe(description: string): this;

isNullable(): boolean;

isOptional(): boolean;

nullable(): ZodNullable<this>;

nullish(): ZodOptional<ZodNullable<this>>;

optional(): ZodOptional<this>;

or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;

parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;

parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;

pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;

promise(): ZodPromise<this>;

readonly(): ZodReadonly<this>;

refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;

refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;

refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;

refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;

safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;

safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;

superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;

superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;

superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;

transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;

}

§Type Parameters

Output = any

z.ZodSchema

§Type Parameters

§Constructors

§Properties

§Methods