openapi-zod-typed-express/dist/runtimeSchemaValidation.d.ts

Simple express runtime parser and documentation swagger generator with 100% support of Typescript static types

import { z } from 'zod';
export type NormalizedIssue = {
    path: string;
    errors: string[];
};
export declare const normalizeZodError: (obj?: unknown) => NormalizedIssue[] | undefined;
export type Mode = 'parse' | 'serialize';
type ZDual<Dec extends z.ZodTypeAny, Enc extends z.ZodTypeAny> = {
    __dual: true;
    parse: Dec;
    serialize: Enc;
    _optional: boolean;
    _nullable: boolean;
};
export type Dualish = z.ZodTypeAny | ZDual<z.ZodTypeAny, z.ZodTypeAny>;
export type DualRawShape = {
    [k: string]: Dualish;
};
export type MaterializeType<S, M extends Mode, T extends 'input' | 'output' = 'output', Out1_DualOutputZSchema = S extends {
    __dual: true;
    __dec__: infer D extends z.ZodTypeAny;
    __enc__: infer E extends z.ZodTypeAny;
} ? MaterializeType<M extends 'parse' ? D : E, M, T> : S extends z.ZodObject<infer Sh, any> ? {
    [K in keyof Sh]: MaterializeType<Sh[K], M, T>;
} : S extends z.ZodArray<infer Elem> ? MaterializeType<Elem, M, T>[] : S extends z.ZodRecord<any, infer V> ? Record<string, MaterializeType<V, M, T>> : S extends z.ZodUnion<infer Opts> ? MaterializeType<Opts[number], M, T> : S extends z.ZodDiscriminatedUnion<any, infer Opts> ? MaterializeType<Opts[number], M, T> : S extends z.ZodOptional<infer Inner> ? MaterializeType<Inner, M, T> | undefined : S extends z.ZodNullable<infer Inner> ? MaterializeType<Inner, M, T> | null : S extends z.ZodTuple<infer Items> ? {
    [I in keyof Items]: Items[I] extends z.ZodTypeAny ? MaterializeType<Items[I], M, T> : never;
} : S extends z.ZodLazy<infer Inner> ? MaterializeType<Inner, M, T> : T extends 'input' ? z.input<S> : z.output<S>, IsOptional = S extends {
    __dual: true;
    _optional: true;
} ? true : false, IsNullable = S extends {
    __dual: true;
    _nullable: true;
} ? true : false, Out1 = IsOptional extends true ? Out1_DualOutputZSchema | undefined : Out1_DualOutputZSchema, Out2 = IsNullable extends true ? Out1 | null : Out1> = Out2;
export type MaterializeTypeShape<Sh, M extends Mode, T extends 'input' | 'output' = 'output'> = {
    [K in keyof Sh]: MaterializeType<Sh[K], M, T>;
};
export declare const zDual: <Dec extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, Enc extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, IsNullable = false, IsOptional = false>(a: {
    parse: Dec;
    serialize: Enc;
    isNullable?: IsNullable | undefined;
    isOptional?: IsOptional | undefined;
}) => {
    __dual: true;
    parse: Dec;
    serialize: Enc;
    nullable: () => {
        __dual: true;
        parse: Dec;
        serialize: Enc;
        nullable: () => any & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
            readonly __dec__: Dec;
            readonly __enc__: Enc;
        };
        optional: () => {
            __dual: true;
            parse: Dec;
            serialize: Enc;
            nullable: () => any & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
                readonly __dec__: Dec;
                readonly __enc__: Enc;
            };
            optional: () => any & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
                readonly __dec__: Dec;
                readonly __enc__: Enc;
            };
            _nullable: true;
            _optional: true;
        } & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
            readonly __dec__: Dec;
            readonly __enc__: Enc;
        };
        _nullable: true;
        _optional: IsOptional;
    } & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
        readonly __dec__: Dec;
        readonly __enc__: Enc;
    };
    optional: () => {
        __dual: true;
        parse: Dec;
        serialize: Enc;
        nullable: () => {
            __dual: true;
            parse: Dec;
            serialize: Enc;
            nullable: () => any & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
                readonly __dec__: Dec;
                readonly __enc__: Enc;
            };
            optional: () => any & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
                readonly __dec__: Dec;
                readonly __enc__: Enc;
            };
            _nullable: true;
            _optional: true;
        } & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
            readonly __dec__: Dec;
            readonly __enc__: Enc;
        };
        optional: () => any & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
            readonly __dec__: Dec;
            readonly __enc__: Enc;
        };
        _nullable: IsNullable;
        _optional: true;
    } & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
        readonly __dec__: Dec;
        readonly __enc__: Enc;
    };
    _nullable: IsNullable;
    _optional: IsOptional;
} & z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> & {
    readonly __dec__: Dec;
    readonly __enc__: Enc;
};
type ValidateInput<S, M extends Mode> = S extends z.ZodTypeAny | ZDual<any, any> ? MaterializeType<S, M, 'input'> : unknown;
type ValidateOutput<S, M extends Mode> = S extends z.ZodTypeAny | ZDual<any, any> ? MaterializeType<S, M, 'output'> : unknown;
type ValidateResult<S, M extends Mode> = z.ZodSafeParseResult<ValidateOutput<S, M>>;
type Validator<S, TT extends Mode> = {
    validate: (value: ValidateInput<S, TT>) => ValidateResult<S, TT>;
    isValid: (value: ValidateInput<S, TT>) => boolean;
};
export declare const materialize: (s: z.ZodTypeAny | ZDual<any, any>, mode: Mode) => z.ZodTypeAny;
export declare const getZodValidator: <S extends z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | ZDual<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>> | null | undefined, TT extends Mode = "parse">(schema: S, extra?: {
    transformTypeMode?: TT | undefined;
} | undefined) => Validator<S, TT>;
export {};