@rexform/validation/dist/index.d.ts

A monad for incremental validation without information loss.

import { Variant } from './ValidationShape';
import { Valid } from './Valid';
import { Invalid } from './Invalid';
export declare type Validation<E, V> = Valid<any, V> | Invalid<E, V>;
export declare const valid: <V>(value: V) => Valid<any, V>;
export declare function invalid<E, V>(value: V): (errors: E | E[]) => Invalid<E, V>;
export declare function invalid<E, V>(value: V, errors: E | E[]): Invalid<E, V>;
export declare function isValid<E, V>(validation: Validation<any, V>): validation is Valid<any, V>;
export declare function isInvalid<E, V>(validation: Validation<E, V>): validation is Invalid<E, V>;
export declare const of: <E, V>(value: V | Valid<any, V> | Invalid<E, V>, errors?: E[] | null | undefined) => Validation<E, V>;
export declare function fromEither<E, V>(initialValue: V): (either: Either<E | E[], V>) => Validation<E, V>;
export declare function fromEither<E, V>(initialValue: V, either: Either<E | E[], V>): Validation<E, V>;
export declare function property<T extends {
    [key: string]: any;
}>(property: string, obj: T): Validation<string, any>;
export declare function property<T extends {
    [key: string]: any;
}>(property: string): (obj: T) => Validation<string, any>;
export declare const allProperties: <E>(obj: {
    [key: string]: Validation<E, any>;
}) => Validation<E, {
    [key: string]: any;
}>;
export declare function validateProperties(validations: {
    [key: string]: (v: any) => Validation<string, any>;
}): (obj: {
    [key: string]: any;
}) => {
    [key: string]: Validation<string, any>;
};
export declare function validateProperties(validations: {
    [key: string]: (v: any) => Validation<string, any>;
}, obj: {
    [key: string]: any;
}): {
    [key: string]: Validation<string, any>;
};
export declare function fromPredicateOr<E, V>(errorFn: (v: V) => E, predicate: (v: V) => boolean): (value: V) => Validation<E, V>;
export declare function fromPredicateOr<E, V>(errorFn: (v: V) => E): (predicate: (v: V) => boolean) => (value: V) => Validation<E, V>;
export declare function errorsOr<T>(alt: T): <E>(validation: Validation<E, any>) => E[] | T;
export declare function errorsOr<E, T>(alt: T, validation: Validation<E, any>): E[] | T;
export declare function empty<E, B>(): Validation<E, B[]>;
export declare function concat<E, A>(listVal: Validation<E, A[]>): (val: Validation<E, A[]>) => Validation<E, A[]>;
export declare function concat<E, A>(listVal: Validation<E, A[]>, val: Validation<E, A[]>): Validation<E, A[]>;
export declare const sequence: <E, A>(validations: Validation<E, A>[]) => Validation<E, A[]>;
export declare function concatErr<E, B>(valB: Validation<E, B>): (valA: Validation<E, any>) => Validation<E, B>;
export declare function concatErr<E, B>(valB: Validation<E, B>, valA: Validation<E, any>): Validation<E, B>;
export declare function map<A, B>(fn: (a: A) => B): <E>(validation: Validation<E, A>) => Validation<E, B>;
export declare function map<A, B, E>(fn: (a: A) => B, validation: Validation<E, A>): Validation<E, B>;
export declare function mapErrors<E, E2, V>(m: (errors: E[]) => E2 | E2[], v: Validation<E, V>): Validation<E2, V>;
export declare function mapErrors<E, E2, V>(m: (errors: E[]) => E2 | E2[]): (v: Validation<E, V>) => Validation<E2, V>;
export declare function mapError<E, E2, V>(m: (error: E) => E2, v: Validation<E, V>): Validation<E2, V>;
export declare function mapError<E, E2, V>(m: (error: E) => E2): (v: Validation<E, V>) => Validation<E2, V>;
export declare function ap<A, B, E>(valFn: Validation<E, (a: A) => B>): (valA: Validation<E, A>) => Validation<E, B>;
export declare function ap<A, B, E>(valFn: Validation<E, (a: A) => B>, valA: Validation<E, A>): Validation<E, B>;
export declare function chain<A, B, E>(fn: (a: A) => Validation<E, B>): (validation: Validation<E, A>) => Validation<E, B>;
export declare function chain<A, B, E>(fn: (a: A) => Validation<E, B>, validation: Validation<E, A>): Validation<E, B>;
export declare function fold<A, E, B>(fnInvalid: (e: E[], a: A) => B, fnValid: (a: A) => B): (validation: Validation<E, A>) => B;
export declare function fold<A, E, B>(fnInvalid: (e: E[], a: A) => B, fnValid: (a: A) => B, validation: Validation<E, A>): B;
export declare type Either<T, U> = {
    fold: <A>(this: Either<T, U>, left: (t: T) => A, right: (u: U) => A) => A;
};
export declare function validateEither<E, V>(validation: Validation<E, V>): (either: Either<E | E[], V>) => Validation<E, V>;
export declare function validateEither<E, V>(validation: Validation<E, V>, either: Either<E | E[], V>): Validation<E, V>;
export declare function validateEitherList<E, V>(validation: Validation<E, V>): (eitherList: Either<E | E[], V>[]) => Validation<E, V>;
export declare function validateEitherList<E, V>(validation: Validation<E, V>, eitherList: Either<E | E[], V>[]): Validation<E, V>;
export declare function validate<E, V>(validation: Validation<E, V>): (validator: (a: V) => Either<E | E[], V>) => Validation<E, V>;
export declare function validate<E, V>(validation: Validation<E, V>, validator: (a: V) => Either<E | E[], V>): Validation<E, V>;
export declare function validateAll<E, V>(validation: Validation<E, V>): (validators: ((a: V) => Either<E | E[], V>)[]) => Validation<E, V>;
export declare function validateAll<E, V>(validation: Validation<E, V>, validators: ((a: V) => Either<E | E[], V>)[]): Validation<E, V>;
export declare const Validation: {
    Variant: typeof Variant;
    Valid: typeof Valid;
    Invalid: typeof Invalid;
    valid: <V>(value: V) => Valid<any, V>;
    invalid: typeof invalid;
    isValid: typeof isValid;
    isInvalid: typeof isInvalid;
    of: <E, V>(value: V | Valid<any, V> | Invalid<E, V>, errors?: E[] | null | undefined) => Validation<E, V>;
    fromEither: typeof fromEither;
    property: typeof property;
    allProperties: <E>(obj: {
        [key: string]: Validation<E, any>;
    }) => Validation<E, {
        [key: string]: any;
    }>;
    validateProperties: typeof validateProperties;
    fromPredicateOr: typeof fromPredicateOr;
    errorsOr: typeof errorsOr;
    empty: typeof empty;
    concat: typeof concat;
    sequence: <E, A>(validations: Validation<E, A>[]) => Validation<E, A[]>;
    concatErr: typeof concatErr;
    map: typeof map;
    mapErrors: typeof mapErrors;
    mapError: typeof mapError;
    ap: typeof ap;
    chain: typeof chain;
    fold: typeof fold;
    validateEither: typeof validateEither;
    validateEitherList: typeof validateEitherList;
    validate: typeof validate;
    validateAll: typeof validateAll;
};
export default Validation;