myzod/libs/index.d.ts

Schema Validation with typescript type inference.

import { IntersectionType } from './types';
import { keySignature, ValidationError, Type, StringType, NumberType, LiteralType, ObjectType, ArrayType, UnionType, PartialType, TupleType, DateType, LazyType, UndefinedType, NullType, NullableType, EnumType, BooleanType, UnknownType, NumberOptions, Literal, ObjectShape, ObjectOptions, AnyType, ArrayOptions, UnionOptions, PartialOpts, IntersectionResult, DeepPartialShape, PartialShape, Eval, ToUnion, StringTypes, OptionalType, BigIntOptions, BigIntType, StringOptions, EnumOptions } from './types';
export { keySignature, ValidationError, Type, Infer, AnyType, ObjectShape, NumberType, BooleanType, StringType, UndefinedType, NullType, ObjectType, ArrayType, TupleType, NullableType, OptionalType, MappedType, DateType, UnknownType, UnionType, IntersectionType, } from './types';
export declare const string: (opts?: StringOptions) => StringType;
export declare const boolean: () => BooleanType;
export declare const number: (opts?: NumberOptions) => NumberType;
export declare const bigint: (opts?: BigIntOptions) => BigIntType;
export declare const unknown: () => UnknownType;
export declare const literal: <T extends Literal>(literal: T) => LiteralType<T>;
export declare const object: <T extends ObjectShape>(shape: T, opts?: ObjectOptions<T>) => ObjectType<T>;
export declare const array: <T extends AnyType>(schema: T, opts?: ArrayOptions<T>) => ArrayType<T>;
export declare const union: <T extends AnyType[]>(schemas: T, opts?: UnionOptions<T>) => UnionType<T>;
export declare const intersection: <T extends AnyType, K extends AnyType>(l: T, r: K) => IntersectionResult<T, K>;
type LiteralWrapper<T extends any> = T extends Literal ? LiteralType<T> : never;
type ToLiteralUnion<T extends Literal[]> = {
    [key in keyof T]: LiteralWrapper<T[key]>;
};
export declare const literals: <T extends Literal[]>(...args: T) => UnionType<ToLiteralUnion<T>>;
export declare const record: <T extends AnyType>(schema: T) => ObjectType<{
    [keySignature]: T;
}>;
export declare const dictionary: <T extends AnyType>(schema: T) => ObjectType<{
    [keySignature]: T extends OptionalType<any> ? T : OptionalType<T>;
}>;
export declare const tuple: <T extends [AnyType, ...AnyType[]] | []>(schemas: T) => TupleType<T>;
export declare const date: () => DateType;
export declare const lazy: <T extends () => AnyType>(fn: T) => LazyType<T>;
export declare function partial<T extends ObjectType<any>, K extends PartialOpts>(schema: T, opts?: K): T extends ObjectType<infer Shape> ? ObjectType<Eval<K extends {
    deep: true;
} ? DeepPartialShape<Shape> : PartialShape<Shape>>> : never;
export declare function partial<T extends AnyType, K extends PartialOpts>(schema: T, opts?: K): PartialType<T, K>;
export declare function pick<T extends ObjectType<any>, K extends T extends ObjectType<infer Shape> ? Shape extends {
    [keySignature]: AnyType;
} ? string : StringTypes<keyof Shape> : never>(schema: T, keys: K[]): T extends ObjectType<infer Shape> ? ObjectType<Eval<Pick<Shape, Extract<StringTypes<keyof Shape>, ToUnion<typeof keys>>> & (Shape extends {
    [keySignature]: AnyType;
} ? Shape extends {
    [keySignature]: infer KeySig;
} ? {
    [key in Exclude<ToUnion<typeof keys>, keyof Shape>]: KeySig;
} : {} : {})>> : never;
export declare function omit<T extends ObjectType<any>, K extends T extends ObjectType<infer Shape> ? StringTypes<keyof Shape> : never>(schema: T, keys: K[]): T extends ObjectType<infer Shape> ? ObjectType<Eval<Omit<Shape, ToUnion<typeof keys>>>> : never;
declare const undefinedValue: () => UndefinedType;
declare const nullValue: () => NullType;
declare const enumValue: <T>(e: T, opts?: EnumOptions<T>) => EnumType<T>;
export { undefinedValue as undefined, nullValue as null, enumValue as enum };
declare const _default: {
    Type: typeof Type;
    string: (opts?: StringOptions) => StringType;
    boolean: () => BooleanType;
    number: (opts?: NumberOptions) => NumberType;
    bigint: (opts?: BigIntOptions) => BigIntType;
    unknown: () => UnknownType;
    literal: <T extends Literal>(literal: T) => LiteralType<T>;
    literals: <T extends Literal[]>(...args: T) => UnionType<ToLiteralUnion<T>>;
    date: () => DateType;
    object: <T extends ObjectShape>(shape: T, opts?: ObjectOptions<T>) => ObjectType<T>;
    array: <T extends AnyType>(schema: T, opts?: ArrayOptions<T>) => ArrayType<T>;
    union: <T extends AnyType[]>(schemas: T, opts?: UnionOptions<T>) => UnionType<T>;
    intersection: <T extends AnyType, K extends AnyType>(l: T, r: K) => IntersectionResult<T, K>;
    record: <T extends AnyType>(schema: T) => ObjectType<{
        [keySignature]: T;
    }>;
    dictionary: <T extends AnyType>(schema: T) => ObjectType<{
        [keySignature]: T extends OptionalType<any> ? T : OptionalType<T>;
    }>;
    tuple: <T extends [AnyType, ...AnyType[]] | []>(schemas: T) => TupleType<T>;
    partial: typeof partial;
    pick: typeof pick;
    omit: typeof omit;
    required: typeof required;
    lazy: <T extends () => AnyType>(fn: T) => LazyType<T>;
    undefined: () => UndefinedType;
    null: () => NullType;
    enum: <T>(e: T, opts?: EnumOptions<T>) => EnumType<T>;
    ValidationError: typeof ValidationError;
    keySignature: typeof keySignature;
    NumberType: typeof NumberType;
    BooleanType: typeof BooleanType;
    StringType: typeof StringType;
    UndefinedType: typeof UndefinedType;
    NullType: typeof NullType;
    ObjectType: typeof ObjectType;
    ArrayType: typeof ArrayType;
    TupleType: typeof TupleType;
    NullableType: typeof NullableType;
    OptionalType: typeof OptionalType;
    DateType: typeof DateType;
    UnknownType: typeof UnknownType;
    UnionType: typeof UnionType;
    IntersectionType: typeof IntersectionType;
};
export default _default;
type Require<T extends AnyType> = T extends NullableType<infer S> ? Require<S> : T extends OptionalType<infer S> ? Require<S> : T;
export declare function required<T extends AnyType>(schema: T): Require<T>;