validata/dist/common.d.ts

Type safe data validation and sanitization

import { Issue, IssueResult, Next, Path, Result, ValueProcessor } from './types';
export interface WithDefault<T> {
    default?: T | (() => T);
}
export interface MaybeOptions {
    incorrectTypeToUndefined?: boolean;
    strictParsing?: boolean;
}
export type UndefinedHandler<T> = () => Result<T> | undefined;
export type Definitely<T> = (next: Next<unknown, T>) => (value: unknown, path?: Path[]) => Result<T>;
export type IsAs<T> = (next: Next<T, T>) => (value: unknown, path: Path[]) => Result<T>;
export type Maybe<T> = (next: Next<unknown, T>) => (value: unknown, path?: Path[]) => Result<T | undefined>;
export type Empty = (value: unknown) => boolean;
export type Check<T> = (value: unknown) => value is T;
export type Convert<T, O = CommonConvertOptions<T>> = (value: unknown, options?: O) => T | undefined;
export type Coerce<T, O> = (options?: O) => (next: Next<T, T>) => (value: T, path: Path[]) => Result<T>;
export type Validate<T, O> = (value: T, path: Path[], options: O) => IssueResult;
export declare const withDefault: <T>(options?: WithDefault<T> | undefined) => UndefinedHandler<T>;
export declare const definitely: <T>(undefinedHandler?: UndefinedHandler<T> | undefined) => Definitely<T>;
export declare const nullOrUndefined: Empty;
export declare const maybe: <T>(empty: Empty, check: Check<T>, options?: MaybeOptions, undefinedHandler?: UndefinedHandler<T> | undefined) => Maybe<T>;
export declare const is: <T>(check: Check<T>, typeName: string) => IsAs<T>;
export declare const as: <T, O extends CommonConvertOptions<T>>(check: Check<T>, convert: Convert<T, O>, typeName: string, undefinedHandler?: UndefinedHandler<T> | undefined, options?: O | undefined) => IsAs<T>;
export interface CommonValidationOptions<T> {
    validator?: (value: T, options?: any, path?: Path[]) => boolean | Issue[];
    validatorOptions?: any;
}
export interface CommonConvertOptions<T> {
    converter?: (value: unknown, options?: any) => T | undefined;
    convertOptions?: any;
}
export declare const isNullable: <T>(processor: ValueProcessor<T>) => ValueProcessor<T | null>;
export declare const asNullable: <T>(processor: ValueProcessor<T>, options?: WithDefault<Exclude<T, undefined> | null> | undefined) => ValueProcessor<Exclude<T, undefined> | null>;
export declare const createIsCheck: <T, TCoerceOptions, TValidationOptions extends CommonValidationOptions<T>>(typeName: string, check: Check<T>, coerce: Coerce<T, TCoerceOptions>, validate: Validate<T, TValidationOptions>) => (options?: (TCoerceOptions & TValidationOptions) | undefined) => ValueProcessor<T>;
export declare const createMaybeCheck: <T, TCoerceOptions, TValidationOptions extends CommonValidationOptions<T>>(typeName: string, check: Check<T>, coerce: Coerce<T, TCoerceOptions>, validate: Validate<T, TValidationOptions>, empty?: Empty) => (options?: (MaybeOptions & TCoerceOptions & TValidationOptions) | undefined) => ValueProcessor<T | undefined>;
export declare const createAsCheck: <T, TConvertOptions extends CommonConvertOptions<T>, TCoerceOptions, TValidationOptions extends CommonValidationOptions<T>>(typeName: string, check: Check<T>, convert: Convert<T, TConvertOptions>, coerce: Coerce<T, TCoerceOptions>, validate: Validate<T, TValidationOptions>) => (options?: (WithDefault<T> & TConvertOptions & TCoerceOptions & TValidationOptions) | undefined) => ValueProcessor<T>;
export declare const createMaybeAsCheck: <T, TConvertOptions extends CommonConvertOptions<T>, TCoerceOptions, TValidationOptions extends CommonValidationOptions<T>>(typeName: string, check: Check<T>, convert: Convert<T, TConvertOptions>, coerce: Coerce<T, TCoerceOptions>, validate: Validate<T, TValidationOptions>, empty?: Empty) => (options?: (MaybeOptions & WithDefault<T> & TConvertOptions & TCoerceOptions & TValidationOptions) | undefined) => ValueProcessor<T | undefined>;
export declare const basicValidation: <T>(value: T, path: Path[], options: CommonValidationOptions<T>) => IssueResult;