AK-21/Graphite-Industrial-Intelligence

1import { type IssueData, type StringValidation, type ZodCustomIssue, ZodError, type ZodErrorMap } from "./ZodError.js";2import type { enumUtil } from "./helpers/enumUtil.js";3import { errorUtil } from "./helpers/errorUtil.js";4import { type AsyncParseReturnType, INVALID, type ParseContext, type ParseInput, type ParseParams, type ParseReturnType, ParseStatus, type SyncParseReturnType } from "./helpers/parseUtil.js";5import type { partialUtil } from "./helpers/partialUtil.js";6import type { Primitive } from "./helpers/typeAliases.js";7import { util, type objectUtil } from "./helpers/util.js";8import type { StandardSchemaV1 } from "./standard-schema.js";9export interface RefinementCtx {10    addIssue: (arg: IssueData) => void;11    path: (string | number)[];12}13export type ZodRawShape = {14    [k: string]: ZodTypeAny;15};16export type ZodTypeAny = ZodType<any, any, any>;17export type TypeOf<T extends ZodType<any, any, any>> = T["_output"];18export type input<T extends ZodType<any, any, any>> = T["_input"];19export type output<T extends ZodType<any, any, any>> = T["_output"];20export type { TypeOf as infer };21export type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;22export interface ZodTypeDef {23    errorMap?: ZodErrorMap | undefined;24    description?: string | undefined;25}26export type RawCreateParams = {27    errorMap?: ZodErrorMap | undefined;28    invalid_type_error?: string | undefined;29    required_error?: string | undefined;30    message?: string | undefined;31    description?: string | undefined;32} | undefined;33export type ProcessedCreateParams = {34    errorMap?: ZodErrorMap | undefined;35    description?: string | undefined;36};37export type SafeParseSuccess<Output> = {38    success: true;39    data: Output;40    error?: never;41};42export type SafeParseError<Input> = {43    success: false;44    error: ZodError<Input>;45    data?: never;46};47export type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;48export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {49    readonly _type: Output;50    readonly _output: Output;51    readonly _input: Input;52    readonly _def: Def;53    get description(): string | undefined;54    "~standard": StandardSchemaV1.Props<Input, Output>;55    abstract _parse(input: ParseInput): ParseReturnType<Output>;56    _getType(input: ParseInput): string;57    _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;58    _processInputParams(input: ParseInput): {59        status: ParseStatus;60        ctx: ParseContext;61    };62    _parseSync(input: ParseInput): SyncParseReturnType<Output>;63    _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;64    parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;65    safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;66    "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;67    parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;68    safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;69    /** Alias of safeParseAsync */70    spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;71    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;72    refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;73    refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;74    refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;75    _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;76    superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;77    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;78    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;79    constructor(def: Def);80    optional(): ZodOptional<this>;81    nullable(): ZodNullable<this>;82    nullish(): ZodOptional<ZodNullable<this>>;83    array(): ZodArray<this>;84    promise(): ZodPromise<this>;85    or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;86    and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;87    transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;88    default(def: util.noUndefined<Input>): ZodDefault<this>;89    default(def: () => util.noUndefined<Input>): ZodDefault<this>;90    brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;91    catch(def: Output): ZodCatch<this>;92    catch(def: (ctx: {93        error: ZodError;94        input: Input;95    }) => Output): ZodCatch<this>;96    describe(description: string): this;97    pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;98    readonly(): ZodReadonly<this>;99    isOptional(): boolean;100    isNullable(): boolean;101}102export type IpVersion = "v4" | "v6";103export type ZodStringCheck = {104    kind: "min";105    value: number;106    message?: string | undefined;107} | {108    kind: "max";109    value: number;110    message?: string | undefined;111} | {112    kind: "length";113    value: number;114    message?: string | undefined;115} | {116    kind: "email";117    message?: string | undefined;118} | {119    kind: "url";120    message?: string | undefined;121} | {122    kind: "emoji";123    message?: string | undefined;124} | {125    kind: "uuid";126    message?: string | undefined;127} | {128    kind: "nanoid";129    message?: string | undefined;130} | {131    kind: "cuid";132    message?: string | undefined;133} | {134    kind: "includes";135    value: string;136    position?: number | undefined;137    message?: string | undefined;138} | {139    kind: "cuid2";140    message?: string | undefined;141} | {142    kind: "ulid";143    message?: string | undefined;144} | {145    kind: "startsWith";146    value: string;147    message?: string | undefined;148} | {149    kind: "endsWith";150    value: string;151    message?: string | undefined;152} | {153    kind: "regex";154    regex: RegExp;155    message?: string | undefined;156} | {157    kind: "trim";158    message?: string | undefined;159} | {160    kind: "toLowerCase";161    message?: string | undefined;162} | {163    kind: "toUpperCase";164    message?: string | undefined;165} | {166    kind: "jwt";167    alg?: string;168    message?: string | undefined;169} | {170    kind: "datetime";171    offset: boolean;172    local: boolean;173    precision: number | null;174    message?: string | undefined;175} | {176    kind: "date";177    message?: string | undefined;178} | {179    kind: "time";180    precision: number | null;181    message?: string | undefined;182} | {183    kind: "duration";184    message?: string | undefined;185} | {186    kind: "ip";187    version?: IpVersion | undefined;188    message?: string | undefined;189} | {190    kind: "cidr";191    version?: IpVersion | undefined;192    message?: string | undefined;193} | {194    kind: "base64";195    message?: string | undefined;196} | {197    kind: "base64url";198    message?: string | undefined;199};200export interface ZodStringDef extends ZodTypeDef {201    checks: ZodStringCheck[];202    typeName: ZodFirstPartyTypeKind.ZodString;203    coerce: boolean;204}205export declare function datetimeRegex(args: {206    precision?: number | null;207    offset?: boolean;208    local?: boolean;209}): RegExp;210export declare class ZodString extends ZodType<string, ZodStringDef, string> {211    _parse(input: ParseInput): ParseReturnType<string>;212    protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;213    _addCheck(check: ZodStringCheck): ZodString;214    email(message?: errorUtil.ErrMessage): ZodString;215    url(message?: errorUtil.ErrMessage): ZodString;216    emoji(message?: errorUtil.ErrMessage): ZodString;217    uuid(message?: errorUtil.ErrMessage): ZodString;218    nanoid(message?: errorUtil.ErrMessage): ZodString;219    cuid(message?: errorUtil.ErrMessage): ZodString;220    cuid2(message?: errorUtil.ErrMessage): ZodString;221    ulid(message?: errorUtil.ErrMessage): ZodString;222    base64(message?: errorUtil.ErrMessage): ZodString;223    base64url(message?: errorUtil.ErrMessage): ZodString;224    jwt(options?: {225        alg?: string;226        message?: string | undefined;227    }): ZodString;228    ip(options?: string | {229        version?: IpVersion;230        message?: string | undefined;231    }): ZodString;232    cidr(options?: string | {233        version?: IpVersion;234        message?: string | undefined;235    }): ZodString;236    datetime(options?: string | {237        message?: string | undefined;238        precision?: number | null;239        offset?: boolean;240        local?: boolean;241    }): ZodString;242    date(message?: string): ZodString;243    time(options?: string | {244        message?: string | undefined;245        precision?: number | null;246    }): ZodString;247    duration(message?: errorUtil.ErrMessage): ZodString;248    regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;249    includes(value: string, options?: {250        message?: string;251        position?: number;252    }): ZodString;253    startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;254    endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;255    min(minLength: number, message?: errorUtil.ErrMessage): ZodString;256    max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;257    length(len: number, message?: errorUtil.ErrMessage): ZodString;258    /**259     * Equivalent to `.min(1)`260     */261    nonempty(message?: errorUtil.ErrMessage): ZodString;262    trim(): ZodString;263    toLowerCase(): ZodString;264    toUpperCase(): ZodString;265    get isDatetime(): boolean;266    get isDate(): boolean;267    get isTime(): boolean;268    get isDuration(): boolean;269    get isEmail(): boolean;270    get isURL(): boolean;271    get isEmoji(): boolean;272    get isUUID(): boolean;273    get isNANOID(): boolean;274    get isCUID(): boolean;275    get isCUID2(): boolean;276    get isULID(): boolean;277    get isIP(): boolean;278    get isCIDR(): boolean;279    get isBase64(): boolean;280    get isBase64url(): boolean;281    get minLength(): number | null;282    get maxLength(): number | null;283    static create: (params?: RawCreateParams & {284        coerce?: true;285    }) => ZodString;286}287export type ZodNumberCheck = {288    kind: "min";289    value: number;290    inclusive: boolean;291    message?: string | undefined;292} | {293    kind: "max";294    value: number;295    inclusive: boolean;296    message?: string | undefined;297} | {298    kind: "int";299    message?: string | undefined;300} | {301    kind: "multipleOf";302    value: number;303    message?: string | undefined;304} | {305    kind: "finite";306    message?: string | undefined;307};308export interface ZodNumberDef extends ZodTypeDef {309    checks: ZodNumberCheck[];310    typeName: ZodFirstPartyTypeKind.ZodNumber;311    coerce: boolean;312}313export declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {314    _parse(input: ParseInput): ParseReturnType<number>;315    static create: (params?: RawCreateParams & {316        coerce?: boolean;317    }) => ZodNumber;318    gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;319    min: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;320    gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;321    lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;322    max: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;323    lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;324    protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;325    _addCheck(check: ZodNumberCheck): ZodNumber;326    int(message?: errorUtil.ErrMessage): ZodNumber;327    positive(message?: errorUtil.ErrMessage): ZodNumber;328    negative(message?: errorUtil.ErrMessage): ZodNumber;329    nonpositive(message?: errorUtil.ErrMessage): ZodNumber;330    nonnegative(message?: errorUtil.ErrMessage): ZodNumber;331    multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;332    step: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;333    finite(message?: errorUtil.ErrMessage): ZodNumber;334    safe(message?: errorUtil.ErrMessage): ZodNumber;335    get minValue(): number | null;336    get maxValue(): number | null;337    get isInt(): boolean;338    get isFinite(): boolean;339}340export type ZodBigIntCheck = {341    kind: "min";342    value: bigint;343    inclusive: boolean;344    message?: string | undefined;345} | {346    kind: "max";347    value: bigint;348    inclusive: boolean;349    message?: string | undefined;350} | {351    kind: "multipleOf";352    value: bigint;353    message?: string | undefined;354};355export interface ZodBigIntDef extends ZodTypeDef {356    checks: ZodBigIntCheck[];357    typeName: ZodFirstPartyTypeKind.ZodBigInt;358    coerce: boolean;359}360export declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {361    _parse(input: ParseInput): ParseReturnType<bigint>;362    _getInvalidInput(input: ParseInput): INVALID;363    static create: (params?: RawCreateParams & {364        coerce?: boolean;365    }) => ZodBigInt;366    gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;367    min: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;368    gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;369    lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;370    max: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;371    lt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;372    protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): ZodBigInt;373    _addCheck(check: ZodBigIntCheck): ZodBigInt;374    positive(message?: errorUtil.ErrMessage): ZodBigInt;375    negative(message?: errorUtil.ErrMessage): ZodBigInt;376    nonpositive(message?: errorUtil.ErrMessage): ZodBigInt;377    nonnegative(message?: errorUtil.ErrMessage): ZodBigInt;378    multipleOf(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;379    get minValue(): bigint | null;380    get maxValue(): bigint | null;381}382export interface ZodBooleanDef extends ZodTypeDef {383    typeName: ZodFirstPartyTypeKind.ZodBoolean;384    coerce: boolean;385}386export declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {387    _parse(input: ParseInput): ParseReturnType<boolean>;388    static create: (params?: RawCreateParams & {389        coerce?: boolean;390    }) => ZodBoolean;391}392export type ZodDateCheck = {393    kind: "min";394    value: number;395    message?: string | undefined;396} | {397    kind: "max";398    value: number;399    message?: string | undefined;400};401export interface ZodDateDef extends ZodTypeDef {402    checks: ZodDateCheck[];403    coerce: boolean;404    typeName: ZodFirstPartyTypeKind.ZodDate;405}406export declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {407    _parse(input: ParseInput): ParseReturnType<this["_output"]>;408    _addCheck(check: ZodDateCheck): ZodDate;409    min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;410    max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;411    get minDate(): Date | null;412    get maxDate(): Date | null;413    static create: (params?: RawCreateParams & {414        coerce?: boolean;415    }) => ZodDate;416}417export interface ZodSymbolDef extends ZodTypeDef {418    typeName: ZodFirstPartyTypeKind.ZodSymbol;419}420export declare class ZodSymbol extends ZodType<symbol, ZodSymbolDef, symbol> {421    _parse(input: ParseInput): ParseReturnType<this["_output"]>;422    static create: (params?: RawCreateParams) => ZodSymbol;423}424export interface ZodUndefinedDef extends ZodTypeDef {425    typeName: ZodFirstPartyTypeKind.ZodUndefined;426}427export declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef, undefined> {428    _parse(input: ParseInput): ParseReturnType<this["_output"]>;429    params?: RawCreateParams;430    static create: (params?: RawCreateParams) => ZodUndefined;431}432export interface ZodNullDef extends ZodTypeDef {433    typeName: ZodFirstPartyTypeKind.ZodNull;434}435export declare class ZodNull extends ZodType<null, ZodNullDef, null> {436    _parse(input: ParseInput): ParseReturnType<this["_output"]>;437    static create: (params?: RawCreateParams) => ZodNull;438}439export interface ZodAnyDef extends ZodTypeDef {440    typeName: ZodFirstPartyTypeKind.ZodAny;441}442export declare class ZodAny extends ZodType<any, ZodAnyDef, any> {443    _any: true;444    _parse(input: ParseInput): ParseReturnType<this["_output"]>;445    static create: (params?: RawCreateParams) => ZodAny;446}447export interface ZodUnknownDef extends ZodTypeDef {448    typeName: ZodFirstPartyTypeKind.ZodUnknown;449}450export declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef, unknown> {451    _unknown: true;452    _parse(input: ParseInput): ParseReturnType<this["_output"]>;453    static create: (params?: RawCreateParams) => ZodUnknown;454}455export interface ZodNeverDef extends ZodTypeDef {456    typeName: ZodFirstPartyTypeKind.ZodNever;457}458export declare class ZodNever extends ZodType<never, ZodNeverDef, never> {459    _parse(input: ParseInput): ParseReturnType<this["_output"]>;460    static create: (params?: RawCreateParams) => ZodNever;461}462export interface ZodVoidDef extends ZodTypeDef {463    typeName: ZodFirstPartyTypeKind.ZodVoid;464}465export declare class ZodVoid extends ZodType<void, ZodVoidDef, void> {466    _parse(input: ParseInput): ParseReturnType<this["_output"]>;467    static create: (params?: RawCreateParams) => ZodVoid;468}469export interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {470    type: T;471    typeName: ZodFirstPartyTypeKind.ZodArray;472    exactLength: {473        value: number;474        message?: string | undefined;475    } | null;476    minLength: {477        value: number;478        message?: string | undefined;479    } | null;480    maxLength: {481        value: number;482        message?: string | undefined;483    } | null;484}485export type ArrayCardinality = "many" | "atleastone";486export type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];487export declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {488    _parse(input: ParseInput): ParseReturnType<this["_output"]>;489    get element(): T;490    min(minLength: number, message?: errorUtil.ErrMessage): this;491    max(maxLength: number, message?: errorUtil.ErrMessage): this;492    length(len: number, message?: errorUtil.ErrMessage): this;493    nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;494    static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;495}496export type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;497export type UnknownKeysParam = "passthrough" | "strict" | "strip";498export interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {499    typeName: ZodFirstPartyTypeKind.ZodObject;500    shape: () => T;501    catchall: Catchall;502    unknownKeys: UnknownKeys;503}504export type mergeTypes<A, B> = {505    [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never;506};507export type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;508export type baseObjectOutputType<Shape extends ZodRawShape> = {509    [k in keyof Shape]: Shape[k]["_output"];510};511export type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;512export type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{513    [k in keyof Shape]: Shape[k]["_input"];514}>;515export type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {516    [k: string]: T["_output"];517};518export type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {519    [k: string]: T["_input"];520};521export type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {522    [k: string]: unknown;523} : unknown;524export type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;525export type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;526export type noUnrecognized<Obj extends object, Shape extends object> = {527    [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;528};529export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {530    _cached: {531        shape: T;532        keys: string[];533    } | null;534    _getCached(): {535        shape: T;536        keys: string[];537    };538    _parse(input: ParseInput): ParseReturnType<this["_output"]>;539    get shape(): T;540    strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;541    strip(): ZodObject<T, "strip", Catchall>;542    passthrough(): ZodObject<T, "passthrough", Catchall>;543    /**544     * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.545     * If you want to pass through unknown properties, use `.passthrough()` instead.546     */547    nonstrict: () => ZodObject<T, "passthrough", Catchall>;548    extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;549    /**550     * @deprecated Use `.extend` instead551     *  */552    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;553    /**554     * Prior to zod@1.0.12 there was a bug in the555     * inferred type of merged objects. Please556     * upgrade if you are experiencing issues.557     */558    merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;559    setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & {560        [k in Key]: Schema;561    }, UnknownKeys, Catchall>;562    catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;563    pick<Mask extends util.Exactly<{564        [k in keyof T]?: true;565    }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;566    omit<Mask extends util.Exactly<{567        [k in keyof T]?: true;568    }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;569    /**570     * @deprecated571     */572    deepPartial(): partialUtil.DeepPartial<this>;573    partial(): ZodObject<{574        [k in keyof T]: ZodOptional<T[k]>;575    }, UnknownKeys, Catchall>;576    partial<Mask extends util.Exactly<{577        [k in keyof T]?: true;578    }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{579        [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];580    }>, UnknownKeys, Catchall>;581    required(): ZodObject<{582        [k in keyof T]: deoptional<T[k]>;583    }, UnknownKeys, Catchall>;584    required<Mask extends util.Exactly<{585        [k in keyof T]?: true;586    }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{587        [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];588    }>, UnknownKeys, Catchall>;589    keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;590    static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;591    static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;592    static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;593}594export type AnyZodObject = ZodObject<any, any, any>;595export type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;596export interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {597    options: T;598    typeName: ZodFirstPartyTypeKind.ZodUnion;599}600export declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {601    _parse(input: ParseInput): ParseReturnType<this["_output"]>;602    get options(): T;603    static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;604}605export type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{606    [key in Discriminator]: ZodTypeAny;607} & ZodRawShape, UnknownKeysParam, ZodTypeAny>;608export interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {609    discriminator: Discriminator;610    options: Options;611    optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;612    typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;613}614export declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {615    _parse(input: ParseInput): ParseReturnType<this["_output"]>;616    get discriminator(): Discriminator;617    get options(): Options;618    get optionsMap(): Map<Primitive, ZodDiscriminatedUnionOption<any>>;619    /**620     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.621     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must622     * have a different value for each object in the union.623     * @param discriminator the name of the discriminator property624     * @param types an array of object schemas625     * @param params626     */627    static create<Discriminator extends string, Types extends readonly [628        ZodDiscriminatedUnionOption<Discriminator>,629        ...ZodDiscriminatedUnionOption<Discriminator>[]630    ]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, Types>;631}632export interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {633    left: T;634    right: U;635    typeName: ZodFirstPartyTypeKind.ZodIntersection;636}637export declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {638    _parse(input: ParseInput): ParseReturnType<this["_output"]>;639    static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;640}641export type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];642export type AssertArray<T> = T extends any[] ? T : never;643export type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{644    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never;645}>;646export type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;647export type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{648    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never;649}>;650export type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;651export interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {652    items: T;653    rest: Rest;654    typeName: ZodFirstPartyTypeKind.ZodTuple;655}656export type AnyZodTuple = ZodTuple<[ZodTypeAny, ...ZodTypeAny[]] | [], ZodTypeAny | null>;657export declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {658    _parse(input: ParseInput): ParseReturnType<this["_output"]>;659    get items(): T;660    rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;661    static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;662}663export interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {664    valueType: Value;665    keyType: Key;666    typeName: ZodFirstPartyTypeKind.ZodRecord;667}668export type KeySchema = ZodType<string | number | symbol, any, any>;669export type RecordType<K extends string | number | symbol, V> = [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;670export declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {671    get keySchema(): Key;672    get valueSchema(): Value;673    _parse(input: ParseInput): ParseReturnType<this["_output"]>;674    get element(): Value;675    static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;676    static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;677}678export interface ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {679    valueType: Value;680    keyType: Key;681    typeName: ZodFirstPartyTypeKind.ZodMap;682}683export declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Map<Key["_output"], Value["_output"]>, ZodMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {684    get keySchema(): Key;685    get valueSchema(): Value;686    _parse(input: ParseInput): ParseReturnType<this["_output"]>;687    static create: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;688}689export interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {690    valueType: Value;691    typeName: ZodFirstPartyTypeKind.ZodSet;692    minSize: {693        value: number;694        message?: string | undefined;695    } | null;696    maxSize: {697        value: number;698        message?: string | undefined;699    } | null;700}701export declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {702    _parse(input: ParseInput): ParseReturnType<this["_output"]>;703    min(minSize: number, message?: errorUtil.ErrMessage): this;704    max(maxSize: number, message?: errorUtil.ErrMessage): this;705    size(size: number, message?: errorUtil.ErrMessage): this;706    nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;707    static create: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;708}709export interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {710    args: Args;711    returns: Returns;712    typeName: ZodFirstPartyTypeKind.ZodFunction;713}714export type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;715export type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;716export declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {717    _parse(input: ParseInput): ParseReturnType<any>;718    parameters(): Args;719    returnType(): Returns;720    args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;721    returns<NewReturnType extends ZodType<any, any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;722    implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;723    strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;724    validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;725    static create(): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>;726    static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>;727    static create<T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>;728    static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: RawCreateParams): ZodFunction<T, U>;729}730export interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {731    getter: () => T;732    typeName: ZodFirstPartyTypeKind.ZodLazy;733}734export declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {735    get schema(): T;736    _parse(input: ParseInput): ParseReturnType<this["_output"]>;737    static create: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;738}739export interface ZodLiteralDef<T = any> extends ZodTypeDef {740    value: T;741    typeName: ZodFirstPartyTypeKind.ZodLiteral;742}743export declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {744    _parse(input: ParseInput): ParseReturnType<this["_output"]>;745    get value(): T;746    static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;747}748export type ArrayKeys = keyof any[];749export type Indices<T> = Exclude<keyof T, ArrayKeys>;750export type EnumValues<T extends string = string> = readonly [T, ...T[]];751export type Values<T extends EnumValues> = {752    [k in T[number]]: k;753};754export interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {755    values: T;756    typeName: ZodFirstPartyTypeKind.ZodEnum;757}758export type Writeable<T> = {759    -readonly [P in keyof T]: T[P];760};761export type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;762export type typecast<A, T> = A extends T ? A : never;763declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;764declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;765export declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {766    _cache: Set<T[number]> | undefined;767    _parse(input: ParseInput): ParseReturnType<this["_output"]>;768    get options(): T;769    get enum(): Values<T>;770    get Values(): Values<T>;771    get Enum(): Values<T>;772    extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;773    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;774    static create: typeof createZodEnum;775}776export interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {777    values: T;778    typeName: ZodFirstPartyTypeKind.ZodNativeEnum;779}780export type EnumLike = {781    [k: string]: string | number;782    [nu: number]: string;783};784export declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>, T[keyof T]> {785    _cache: Set<T[keyof T]> | undefined;786    _parse(input: ParseInput): ParseReturnType<T[keyof T]>;787    get enum(): T;788    static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;789}790export interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {791    type: T;792    typeName: ZodFirstPartyTypeKind.ZodPromise;793}794export declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {795    unwrap(): T;796    _parse(input: ParseInput): ParseReturnType<this["_output"]>;797    static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;798}799export type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;800export type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;801export type RefinementEffect<T> = {802    type: "refinement";803    refinement: (arg: T, ctx: RefinementCtx) => any;804};805export type TransformEffect<T> = {806    type: "transform";807    transform: (arg: T, ctx: RefinementCtx) => any;808};809export type PreprocessEffect<T> = {810    type: "preprocess";811    transform: (arg: T, ctx: RefinementCtx) => any;812};813export type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;814export interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {815    schema: T;816    typeName: ZodFirstPartyTypeKind.ZodEffects;817    effect: Effect<any>;818}819export declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {820    innerType(): T;821    sourceType(): T;822    _parse(input: ParseInput): ParseReturnType<this["_output"]>;823    static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;824    static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;825}826export { ZodEffects as ZodTransformer };827export interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {828    innerType: T;829    typeName: ZodFirstPartyTypeKind.ZodOptional;830}831export type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;832export declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {833    _parse(input: ParseInput): ParseReturnType<this["_output"]>;834    unwrap(): T;835    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;836}837export interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {838    innerType: T;839    typeName: ZodFirstPartyTypeKind.ZodNullable;840}841export type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;842export declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {843    _parse(input: ParseInput): ParseReturnType<this["_output"]>;844    unwrap(): T;845    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;846}847export interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {848    innerType: T;849    defaultValue: () => util.noUndefined<T["_input"]>;850    typeName: ZodFirstPartyTypeKind.ZodDefault;851}852export declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {853    _parse(input: ParseInput): ParseReturnType<this["_output"]>;854    removeDefault(): T;855    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {856        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);857    }) => ZodDefault<Inner>;858}859export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {860    innerType: T;861    catchValue: (ctx: {862        error: ZodError;863        input: unknown;864    }) => T["_input"];865    typeName: ZodFirstPartyTypeKind.ZodCatch;866}867export declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {868    _parse(input: ParseInput): ParseReturnType<this["_output"]>;869    removeCatch(): T;870    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {871        catch: Inner["_output"] | (() => Inner["_output"]);872    }) => ZodCatch<Inner>;873}874export interface ZodNaNDef extends ZodTypeDef {875    typeName: ZodFirstPartyTypeKind.ZodNaN;876}877export declare class ZodNaN extends ZodType<number, ZodNaNDef, number> {878    _parse(input: ParseInput): ParseReturnType<any>;879    static create: (params?: RawCreateParams) => ZodNaN;880}881export interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {882    type: T;883    typeName: ZodFirstPartyTypeKind.ZodBranded;884}885export declare const BRAND: unique symbol;886export type BRAND<T extends string | number | symbol> = {887    [BRAND]: {888        [k in T]: true;889    };890};891export declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {892    _parse(input: ParseInput): ParseReturnType<any>;893    unwrap(): T;894}895export interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {896    in: A;897    out: B;898    typeName: ZodFirstPartyTypeKind.ZodPipeline;899}900export declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {901    _parse(input: ParseInput): ParseReturnType<any>;902    static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;903}904type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {905    readonly [Symbol.toStringTag]: string;906} | Date | Error | Generator | Promise<unknown> | RegExp;907type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;908export interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {909    innerType: T;910    typeName: ZodFirstPartyTypeKind.ZodReadonly;911}912export declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {913    _parse(input: ParseInput): ParseReturnType<this["_output"]>;914    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;915    unwrap(): T;916}917type CustomParams = CustomErrorParams & {918    fatal?: boolean;919};920export declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams), 921/**922 * @deprecated923 *924 * Pass `fatal` into the params object instead:925 *926 * ```ts927 * z.string().custom((val) => val.length > 5, { fatal: false })928 * ```929 *930 */931fatal?: boolean): ZodType<T, ZodTypeDef, T>;932export { ZodType as Schema, ZodType as ZodSchema };933export declare const late: {934    object: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;935};936export declare enum ZodFirstPartyTypeKind {937    ZodString = "ZodString",938    ZodNumber = "ZodNumber",939    ZodNaN = "ZodNaN",940    ZodBigInt = "ZodBigInt",941    ZodBoolean = "ZodBoolean",942    ZodDate = "ZodDate",943    ZodSymbol = "ZodSymbol",944    ZodUndefined = "ZodUndefined",945    ZodNull = "ZodNull",946    ZodAny = "ZodAny",947    ZodUnknown = "ZodUnknown",948    ZodNever = "ZodNever",949    ZodVoid = "ZodVoid",950    ZodArray = "ZodArray",951    ZodObject = "ZodObject",952    ZodUnion = "ZodUnion",953    ZodDiscriminatedUnion = "ZodDiscriminatedUnion",954    ZodIntersection = "ZodIntersection",955    ZodTuple = "ZodTuple",956    ZodRecord = "ZodRecord",957    ZodMap = "ZodMap",958    ZodSet = "ZodSet",959    ZodFunction = "ZodFunction",960    ZodLazy = "ZodLazy",961    ZodLiteral = "ZodLiteral",962    ZodEnum = "ZodEnum",963    ZodEffects = "ZodEffects",964    ZodNativeEnum = "ZodNativeEnum",965    ZodOptional = "ZodOptional",966    ZodNullable = "ZodNullable",967    ZodDefault = "ZodDefault",968    ZodCatch = "ZodCatch",969    ZodPromise = "ZodPromise",970    ZodBranded = "ZodBranded",971    ZodPipeline = "ZodPipeline",972    ZodReadonly = "ZodReadonly"973}974export type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;975declare abstract class Class {976    constructor(..._: any[]);977}978declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;979declare const stringType: (params?: RawCreateParams & {980    coerce?: true;981}) => ZodString;982declare const numberType: (params?: RawCreateParams & {983    coerce?: boolean;984}) => ZodNumber;985declare const nanType: (params?: RawCreateParams) => ZodNaN;986declare const bigIntType: (params?: RawCreateParams & {987    coerce?: boolean;988}) => ZodBigInt;989declare const booleanType: (params?: RawCreateParams & {990    coerce?: boolean;991}) => ZodBoolean;992declare const dateType: (params?: RawCreateParams & {993    coerce?: boolean;994}) => ZodDate;995declare const symbolType: (params?: RawCreateParams) => ZodSymbol;996declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;997declare const nullType: (params?: RawCreateParams) => ZodNull;998declare const anyType: (params?: RawCreateParams) => ZodAny;999declare const unknownType: (params?: RawCreateParams) => ZodUnknown;1000declare const neverType: (params?: RawCreateParams) => ZodNever;1001declare const voidType: (params?: RawCreateParams) => ZodVoid;1002declare const arrayType: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;1003declare const objectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;1004declare const strictObjectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;1005declare const unionType: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;1006declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;1007declare const intersectionType: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;1008declare const tupleType: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;1009declare const recordType: typeof ZodRecord.create;1010declare const mapType: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;1011declare const setType: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;1012declare const functionType: typeof ZodFunction.create;1013declare const lazyType: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;1014declare const literalType: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;1015declare const enumType: typeof createZodEnum;1016declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;1017declare const promiseType: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;1018declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;1019declare const optionalType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;1020declare const nullableType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;1021declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;1022declare const pipelineType: typeof ZodPipeline.create;1023declare const ostring: () => ZodOptional<ZodString>;1024declare const onumber: () => ZodOptional<ZodNumber>;1025declare const oboolean: () => ZodOptional<ZodBoolean>;1026export declare const coerce: {1027    string: (typeof ZodString)["create"];1028    number: (typeof ZodNumber)["create"];1029    boolean: (typeof ZodBoolean)["create"];1030    bigint: (typeof ZodBigInt)["create"];1031    date: (typeof ZodDate)["create"];1032};1033export { anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, dateType as date, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, instanceOfType as instanceof, intersectionType as intersection, lazyType as lazy, literalType as literal, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, oboolean, onumber, optionalType as optional, ostring, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, recordType as record, setType as set, strictObjectType as strictObject, stringType as string, symbolType as symbol, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, };1034export declare const NEVER: never;1035