ascertain/build/index.d.ts

0-Deps, simple, fast, for browser and node js object schema validator

declare abstract class Operator<T> {
    readonly schemas: Schema<T>[];
    constructor(schemas: Schema<T>[]);
}
export declare const $keys: unique symbol;
export declare const $values: unique symbol;
export declare const $strict: unique symbol;
export type Schema<T> = T extends Record<string | number | symbol, unknown> ? {
    [K in keyof T]?: Schema<T[K]> | unknown;
} & {
    [$keys]?: Schema<keyof T>;
} & {
    [$values]?: Schema<T[keyof T]>;
} & {
    [$strict]?: boolean;
} : T extends Array<infer A> ? Schema<A>[] | unknown : unknown;
declare class Or<T> extends Operator<T> {
}
export declare const or: <T>(...schemas: Schema<T>[]) => Or<T>;
declare class And<T> extends Operator<T> {
}
export declare const and: <T>(...schemas: Schema<T>[]) => And<T>;
declare class Optional<T> extends Operator<T> {
    constructor(schema: Schema<T>);
}
export declare const optional: <T>(schema: Schema<T>) => Optional<T>;
declare class Tuple<T> extends Operator<T> {
}
export declare const tuple: <T>(...schemas: Schema<T>[]) => Tuple<T>;
export declare const fromBase64: (value: string) => string;
export declare const asError: <T>(message: string) => T;
export declare const as: {
    string: (value: string | undefined) => string;
    number: (value: string | undefined) => number;
    date: (value: string | undefined) => Date;
    time: (value: string | undefined, conversionFactor?: number) => number;
    boolean: (value: string | undefined) => boolean;
    array: (value: string | undefined, delimiter: string) => string[];
    json: <T = object>(value: string | undefined) => T;
    base64: (value: string | undefined) => string;
};
export interface ErrorFormatter {
    (value: unknown, expected: unknown, path: string, subject: string): string;
}
export declare const formatError: ErrorFormatter;
export declare const compile: <T>(schema: Schema<T>, rootName: string) => (data: T) => any;
export declare const ascertain: <T>(schema: Schema<T>, data: T, rootName?: string) => void;
export {};