Class ZodObject<T, UnknownKeys, Catchall, Output, Input>

Type Parameters

Hierarchy (View Summary)

Constructors

constructor

Properties

_def _input _output _type augment nonstrict spa create lazycreate strictCreate

Accessors

description shape

Methods

_getCached _getOrReturnCtx _getType _parse _parseAsync _parseSync _processInputParams _refinement and array brand catch catchall deepPartial default describe extend isNullable isOptional keyof merge nullable nullish omit optional or parse parseAsync partial passthrough pick pipe promise readonly refine refinement required safeParse safeParseAsync setKey strict strip superRefine transform

Constructors

constructor

Properties

Readonly_def

_def: ZodObjectDef<T, UnknownKeys, Catchall>

Readonly_input

_input: Input

Readonly_output

_output: Output

Readonly_type

_type: Output

augment

augment: <Augmentation extends ZodRawShape>(
    augmentation: Augmentation,
) => ZodObject<
    extendShape<T, Augmentation>,
    UnknownKeys,
    Catchall,
    objectOutputType<extendShape<T, Augmentation>, Catchall, UnknownKeys>,
    objectInputType<extendShape<T, Augmentation>, Catchall, UnknownKeys>,
>

Deprecated

Use .extend instead

nonstrict

nonstrict: () => ZodObject<
    T,
    "passthrough",
    Catchall,
    objectOutputType<T, Catchall, "passthrough">,
    objectInputType<T, Catchall, "passthrough">,
>

Deprecated

In most cases, this is no longer needed - unknown properties are now silently stripped. If you want to pass through unknown properties, use .passthrough() instead.

spa

spa: (
    data: unknown,
    params?: Partial<ParseParams>,
) => Promise<SafeParseReturnType<Input, Output>>

Alias of safeParseAsync

Staticcreate

create: <T_1 extends ZodRawShape>(
    shape: T_1,
    params?: RawCreateParams,
) => ZodObject<
    T_1,
    "strip",
    ZodTypeAny,
    {
        [k in string
        | number
        | symbol]: addQuestionMarks<baseObjectOutputType<T_1>, any>[k]
    },
    { [k_1 in string
    | number
    | symbol]: baseObjectInputType<T_1>[k_1] },
>

Staticlazycreate

lazycreate: <T_1 extends ZodRawShape>(
    shape: () => T_1,
    params?: RawCreateParams,
) => ZodObject<
    T_1,
    "strip",
    ZodTypeAny,
    {
        [k in string
        | number
        | symbol]: addQuestionMarks<baseObjectOutputType<T_1>, any>[k]
    },
    { [k_1 in string
    | number
    | symbol]: baseObjectInputType<T_1>[k_1] },
>

StaticstrictCreate

strictCreate: <T_1 extends ZodRawShape>(
    shape: T_1,
    params?: RawCreateParams,
) => ZodObject<
    T_1,
    "strict",
    ZodTypeAny,
    {
        [k in string
        | number
        | symbol]: addQuestionMarks<baseObjectOutputType<T_1>, any>[k]
    },
    { [k_1 in string
    | number
    | symbol]: baseObjectInputType<T_1>[k_1] },
>

Accessors

description

  • get description(): undefined | string

  • Returns undefined | string

shape

  • get shape(): T

  • Returns T

Methods

_getCached

  • _getCached(): { keys: string[]; shape: T }

  • Returns { keys: string[]; shape: T }

_getOrReturnCtx

_getType

  • _getType(input: ParseInput): string

  • Parameters

    Returns string

_parse

_parseAsync

_parseSync

_processInputParams

_refinement

and

array

brand

catch

catchall

deepPartial

default

describe

  • describe(description: string): this

  • Parameters

    • description: string

    Returns this

extend

isNullable

  • isNullable(): boolean

  • Returns boolean

isOptional

  • isOptional(): boolean

  • Returns boolean

keyof

  • keyof(): ZodEnum<CastToStringTuple<UnionToTuple<keyof T, []>>>

  • Returns ZodEnum<CastToStringTuple<UnionToTuple<keyof T, []>>>

merge

nullable

nullish

omit

optional

or

parse

  • parse(data: unknown, params?: Partial<ParseParams>): Output

  • Parameters

    Returns Output

parseAsync

  • parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>

  • Parameters

    Returns Promise<Output>

partial

  • partial(): ZodObject<
        { [k in string
        | number
        | symbol]: ZodOptional<T[k]> },
        UnknownKeys,
        Catchall,
        objectOutputType<
            { [k in string
            | number
            | symbol]: ZodOptional<T[k]> },
            Catchall,
            UnknownKeys,
        >,
        objectInputType<
            { [k in string
            | number
            | symbol]: ZodOptional<T[k]> },
            Catchall,
            UnknownKeys,
        >,
    >

  • Returns ZodObject<
        { [k in string
        | number
        | symbol]: ZodOptional<T[k]> },
        UnknownKeys,
        Catchall,
        objectOutputType<
            { [k in string
            | number
            | symbol]: ZodOptional<T[k]> },
            Catchall,
            UnknownKeys,
        >,
        objectInputType<
            { [k in string
            | number
            | symbol]: ZodOptional<T[k]> },
            Catchall,
            UnknownKeys,
        >,
    >

  • partial<Mask extends Exactly<{ [k in string | number | symbol]?: true }, Mask>>(
        mask: Mask,
    ): ZodObject<
        {
            [k in string
            | number
            | symbol]: k extends keyof T
                ? {
                    [k in string | number | symbol]: k extends keyof Mask
                        ? ZodOptional<T[k<k>]>
                        : T[k]
                }[k<k>]
                : never
        },
        UnknownKeys,
        Catchall,
        objectOutputType<
            {
                [k in string
                | number
                | symbol]: k extends keyof T
                    ? {
                        [k in string | number | symbol]: k extends keyof Mask
                            ? ZodOptional<T[k<k>]>
                            : T[k]
                    }[k<k>]
                    : never
            },
            Catchall,
            UnknownKeys,
        >,
        objectInputType<
            {
                [k in string
                | number
                | symbol]: k extends keyof T
                    ? {
                        [k in string | number | symbol]: k extends keyof Mask
                            ? ZodOptional<T[k<k>]>
                            : T[k]
                    }[k<k>]
                    : never
            },
            Catchall,
            UnknownKeys,
        >,
    >

  • Type Parameters

    • Mask extends Exactly<{ [k in string | number | symbol]?: true }, Mask>

    Parameters

    Returns ZodObject<
        {
            [k in string
            | number
            | symbol]: k extends keyof T
                ? {
                    [k in string | number | symbol]: k extends keyof Mask
                        ? ZodOptional<T[k<k>]>
                        : T[k]
                }[k<k>]
                : never
        },
        UnknownKeys,
        Catchall,
        objectOutputType<
            {
                [k in string
                | number
                | symbol]: k extends keyof T
                    ? {
                        [k in string | number | symbol]: k extends keyof Mask
                            ? ZodOptional<T[k<k>]>
                            : T[k]
                    }[k<k>]
                    : never
            },
            Catchall,
            UnknownKeys,
        >,
        objectInputType<
            {
                [k in string
                | number
                | symbol]: k extends keyof T
                    ? {
                        [k in string | number | symbol]: k extends keyof Mask
                            ? ZodOptional<T[k<k>]>
                            : T[k]
                    }[k<k>]
                    : never
            },
            Catchall,
            UnknownKeys,
        >,
    >

passthrough

pick

pipe

promise

readonly

refine

refinement

required

  • required(): ZodObject<
        { [k in string
        | number
        | symbol]: deoptional<T[k]> },
        UnknownKeys,
        Catchall,
        objectOutputType<
            { [k in string
            | number
            | symbol]: deoptional<T[k]> },
            Catchall,
            UnknownKeys,
        >,
        objectInputType<
            { [k in string
            | number
            | symbol]: deoptional<T[k]> },
            Catchall,
            UnknownKeys,
        >,
    >

  • Returns ZodObject<
        { [k in string
        | number
        | symbol]: deoptional<T[k]> },
        UnknownKeys,
        Catchall,
        objectOutputType<
            { [k in string
            | number
            | symbol]: deoptional<T[k]> },
            Catchall,
            UnknownKeys,
        >,
        objectInputType<
            { [k in string
            | number
            | symbol]: deoptional<T[k]> },
            Catchall,
            UnknownKeys,
        >,
    >

  • required<Mask extends Exactly<{ [k in string | number | symbol]?: true }, Mask>>(
        mask: Mask,
    ): ZodObject<
        {
            [k in string
            | number
            | symbol]: k extends keyof T
                ? {
                    [k in string | number | symbol]: k extends keyof Mask
                        ? deoptional<T[k<k>]>
                        : T[k]
                }[k<k>]
                : never
        },
        UnknownKeys,
        Catchall,
        objectOutputType<
            {
                [k in string
                | number
                | symbol]: k extends keyof T
                    ? {
                        [k in string | number | symbol]: k extends keyof Mask
                            ? deoptional<T[k<k>]>
                            : T[k]
                    }[k<k>]
                    : never
            },
            Catchall,
            UnknownKeys,
        >,
        objectInputType<
            {
                [k in string
                | number
                | symbol]: k extends keyof T
                    ? {
                        [k in string | number | symbol]: k extends keyof Mask
                            ? deoptional<T[k<k>]>
                            : T[k]
                    }[k<k>]
                    : never
            },
            Catchall,
            UnknownKeys,
        >,
    >

  • Type Parameters

    • Mask extends Exactly<{ [k in string | number | symbol]?: true }, Mask>

    Parameters

    Returns ZodObject<
        {
            [k in string
            | number
            | symbol]: k extends keyof T
                ? {
                    [k in string | number | symbol]: k extends keyof Mask
                        ? deoptional<T[k<k>]>
                        : T[k]
                }[k<k>]
                : never
        },
        UnknownKeys,
        Catchall,
        objectOutputType<
            {
                [k in string
                | number
                | symbol]: k extends keyof T
                    ? {
                        [k in string | number | symbol]: k extends keyof Mask
                            ? deoptional<T[k<k>]>
                            : T[k]
                    }[k<k>]
                    : never
            },
            Catchall,
            UnknownKeys,
        >,
        objectInputType<
            {
                [k in string
                | number
                | symbol]: k extends keyof T
                    ? {
                        [k in string | number | symbol]: k extends keyof Mask
                            ? deoptional<T[k<k>]>
                            : T[k]
                    }[k<k>]
                    : never
            },
            Catchall,
            UnknownKeys,
        >,
    >

safeParse

safeParseAsync

setKey

strict

strip

superRefine

transform

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods