@karmaniverous/get-dotenv
    Preparing search index...

    Interface ZodPreprocess<B>

    interface ZodPreprocess<B extends SomeType = z.core.$ZodType> {
        _def: $ZodPipeDef<z.core.$ZodTransform<unknown, unknown>, B>;
        _input: unknown;
        _output: z.core.output<B>;
        _zod: $ZodPreprocessInternals<B>;
        "~standard": z.ZodStandardSchemaWithJSON<z.ZodPreprocess<B>>;
        def: $ZodPreprocessDef<B>;
        description?: string;
        in: z.core.$ZodTransform;
        out: B;
        spa: (
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ) => Promise<ZodSafeParseResult<z.core.output<B>>>;
        type: "pipe";
        and<T extends SomeType>(
            incoming: T,
        ): z.ZodIntersection<z.ZodPreprocess<B>, T>;
        apply<T>(fn: (schema: this) => T): T;
        array(): z.ZodArray<z.ZodPreprocess<B>>;
        brand<
            T extends PropertyKey = PropertyKey,
            Dir extends "out" | "in" | "inout" = "out",
        >(
            value?: T,
        ): PropertyKey extends T
            ? z.ZodPreprocess<B>
            : $ZodBranded<z.ZodPreprocess<B>, T, Dir>;
        catch(def: z.core.output<B>): z.ZodCatch<z.ZodPreprocess<B>>;
        catch(
            def: (ctx: $ZodCatchCtx) => z.core.output<B>,
        ): z.ZodCatch<z.ZodPreprocess<B>>;
        check(
            ...checks: (
                CheckFn<z.core.output<B>>
                | z.core.$ZodCheck<z.core.output<B>>
            )[],
        ): this;
        clone(
            def?: $ZodPipeDef<z.core.$ZodTransform<unknown, unknown>, B>,
            params?: { parent: boolean },
        ): this;
        decode(data: unknown, params?: ParseContext<$ZodIssue>): z.core.output<B>;
        decodeAsync(
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ): Promise<z.core.output<B>>;
        default(
            def: NoUndefined<z.core.output<B>>,
        ): z.ZodDefault<z.ZodPreprocess<B>>;
        default(
            def: () => NoUndefined<z.core.output<B>>,
        ): z.ZodDefault<z.ZodPreprocess<B>>;
        describe(description: string): this;
        encode(data: z.core.output<B>, params?: ParseContext<$ZodIssue>): unknown;
        encodeAsync(
            data: z.core.output<B>,
            params?: ParseContext<$ZodIssue>,
        ): Promise<unknown>;
        exactOptional(): z.ZodExactOptional<z.ZodPreprocess<B>>;
        isNullable(): boolean;
        isOptional(): boolean;
        meta(): | {
            deprecated?: boolean;
            description?: string;
            id?: string;
            title?: string;
            [key: string]: unknown;
        }
        | undefined;
        meta(
            data: {
                deprecated?: boolean;
                description?: string;
                id?: string;
                title?: string;
                [key: string]: unknown;
            },
        ): this;
        nonoptional(
            params?:
                | string
                | {
                    error?: string
                    | $ZodErrorMap<$ZodIssueInvalidType<unknown>>;
                    message?: string;
                },
        ): z.ZodNonOptional<z.ZodPreprocess<B>>;
        nullable(): z.ZodNullable<z.ZodPreprocess<B>>;
        nullish(): z.ZodOptional<z.ZodNullable<z.ZodPreprocess<B>>>;
        optional(): z.ZodOptional<z.ZodPreprocess<B>>;
        or<T extends SomeType>(option: T): z.ZodUnion<[z.ZodPreprocess<B>, T]>;
        overwrite(fn: (x: z.core.output<B>) => z.core.output<B>): this;
        parse(data: unknown, params?: ParseContext<$ZodIssue>): z.core.output<B>;
        parseAsync(
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ): Promise<z.core.output<B>>;
        pipe<
            T extends
                z.core.$ZodType<
                    any,
                    z.core.output<B>,
                    $ZodTypeInternals<any, z.core.output<B>>,
                >,
        >(
            target:
                | T
                | z.core.$ZodType<
                    any,
                    z.core.output<B>,
                    $ZodTypeInternals<any, z.core.output<B>>,
                >,
        ): z.ZodPipe<z.ZodPreprocess<B>, T>;
        prefault(def: () => unknown): z.ZodPrefault<z.ZodPreprocess<B>>;
        prefault(def: unknown): z.ZodPrefault<z.ZodPreprocess<B>>;
        readonly(): z.ZodReadonly<z.ZodPreprocess<B>>;
        refine<Ch extends (arg: z.core.output<B>) => unknown>(
            check: Ch,
            params?:
                | string
                | {
                    abort?: boolean;
                    error?: string
                    | $ZodErrorMap<NonNullable<$ZodIssue>>;
                    message?: string;
                    params?: Record<string, any>;
                    path?: PropertyKey[];
                    when?: (payload: ParsePayload) => boolean;
                },
        ): Ch extends (arg: any) => arg is R
            ? z.ZodPreprocess<B> & z.ZodType<
                R,
                unknown,
                $ZodTypeInternals<R, unknown>,
            >
            : z.ZodPreprocess<B>;
        register<
            R extends
                $ZodRegistry<
                    MetadataType,
                    z.core.$ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>,
                >,
        >(
            registry: R,
            ...meta: z.ZodPreprocess<B> extends R["_schema"]
                ? undefined extends R["_meta"]
                    ? [$replace<R["_meta"], R["_schema"] & z.ZodPreprocess<B>>?]
                    : [$replace<R["_meta"], R["_schema"] & z.ZodPreprocess<B>>]
                : ["Incompatible schema"],
        ): this;
        safeDecode(
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ): ZodSafeParseResult<z.core.output<B>>;
        safeDecodeAsync(
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ): Promise<ZodSafeParseResult<z.core.output<B>>>;
        safeEncode(
            data: z.core.output<B>,
            params?: ParseContext<$ZodIssue>,
        ): ZodSafeParseResult<unknown>;
        safeEncodeAsync(
            data: z.core.output<B>,
            params?: ParseContext<$ZodIssue>,
        ): Promise<ZodSafeParseResult<unknown>>;
        safeParse(
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ): ZodSafeParseResult<z.core.output<B>>;
        safeParseAsync(
            data: unknown,
            params?: ParseContext<$ZodIssue>,
        ): Promise<ZodSafeParseResult<z.core.output<B>>>;
        superRefine(
            refinement: (
                arg: z.core.output<B>,
                ctx: $RefinementCtx<z.core.output<B>>,
            ) => void | Promise<void>,
            params?: $ZodSuperRefineParams,
        ): this;
        toJSONSchema(
            params?: ToJSONSchemaParams,
        ): ZodStandardJSONSchemaPayload<z.ZodPreprocess<B>>;
        transform<NewOut>(
            transform: (
                arg: z.core.output<B>,
                ctx: $RefinementCtx<z.core.output<B>>,
            ) => NewOut | Promise<NewOut>,
        ): z.ZodPipe<
            z.ZodPreprocess<B>,
            z.ZodTransform<Awaited<NewOut>, z.core.output<B>>,
        >;
        with(
            ...checks: (
                CheckFn<z.core.output<B>>
                | z.core.$ZodCheck<z.core.output<B>>
            )[],
        ): this;
    }

    Type Parameters

    Hierarchy (View Summary)

    Index

    Properties

    _def _input _output _zod ~standard def description? in out spa type

    Methods

    and apply array brand catch check clone decode decodeAsync default describe encode encodeAsync exactOptional isNullable isOptional meta nonoptional nullable nullish optional or overwrite parse parseAsync pipe prefault readonly refine register safeDecode safeDecodeAsync safeEncode safeEncodeAsync safeParse safeParseAsync superRefine toJSONSchema transform with

    Properties

    _def

    _def: $ZodPipeDef<z.core.$ZodTransform<unknown, unknown>, B>

    Use .def instead.

    _input

    _input: unknown

    Use z.input<typeof schema> instead.

    _output

    _output: z.core.output<B>

    Use z.output<typeof schema> instead.

    _zod

    _zod: $ZodPreprocessInternals<B>
    "~standard": z.ZodStandardSchemaWithJSON<z.ZodPreprocess<B>>
    def: $ZodPreprocessDef<B>
    description?: string
    in: z.core.$ZodTransform
    out: B
    spa: (
        data: unknown,
        params?: ParseContext<$ZodIssue>,
    ) => Promise<ZodSafeParseResult<z.core.output<B>>>
    type: "pipe"

    Methods

    • Type Parameters

      • T

      Parameters

      • fn: (schema: this) => T

      Returns T

    • Returns a new instance that has been registered in z.globalRegistry with the specified description

      Parameters

      • description: string

      Returns this

    • Returns boolean

      Try safe-parsing null (this is what isNullable does internally):

      const schema = z.string().nullable();
      const isNullable = schema.safeParse(null).success; // true

    • Returns boolean

      Try safe-parsing undefined (this is what isOptional does internally):

      const schema = z.string().optional();
      const isOptional = schema.safeParse(undefined).success; // true

    • Returns the metadata associated with this instance in z.globalRegistry

      Returns
          | {
              deprecated?: boolean;
              description?: string;
              id?: string;
              title?: string;
              [key: string]: unknown;
          }
          | undefined

    • Returns a new instance that has been registered in z.globalRegistry with the specified metadata

      Parameters

      • data: {
            deprecated?: boolean;
            description?: string;
            id?: string;
            title?: string;
            [key: string]: unknown;
        }

      Returns this

    • Type Parameters

      Parameters

      • check: Ch
      • Optionalparams:
            | string
            | {
                abort?: boolean;
                error?: string
                | $ZodErrorMap<NonNullable<$ZodIssue>>;
                message?: string;
                params?: Record<string, any>;
                path?: PropertyKey[];
                when?: (payload: ParsePayload) => boolean;
            }
        • string
        • {
              abort?: boolean;
              error?: string | $ZodErrorMap<NonNullable<$ZodIssue>>;
              message?: string;
              params?: Record<string, any>;
              path?: PropertyKey[];
              when?: (payload: ParsePayload) => boolean;
          }
          • Optionalabort?: boolean

            If true, no later checks will be executed if this check fails. Default false.

          • Optionalerror?: string | $ZodErrorMap<NonNullable<$ZodIssue>>
          • Optionalmessage?: string

            This parameter is deprecated. Use error instead.

          • Optionalparams?: Record<string, any>
          • Optionalpath?: PropertyKey[]
          • Optionalwhen?: (payload: ParsePayload) => boolean

            If provided, the check runs only when this returns true. By default, it is skipped if prior parsing produced aborting issues.

      Returns Ch extends (arg: any) => arg is R
          ? z.ZodPreprocess<B> & z.ZodType<
              R,
              unknown,
              $ZodTypeInternals<R, unknown>,
          >
          : z.ZodPreprocess<B>

    Settings

    Member Visibility

    On This Page

    Properties
    Methods