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

A monad for incremental validation without information loss.

import { ValidationShape, Variant } from './ValidationShape';
import Validation, { Either } from './index';
import { Invalid } from './Invalid';
export declare class Valid<E, V> implements ValidationShape<E, V> {
    readonly variant: Variant.Valid;
    readonly value: V;
    constructor(value: V);
    isValid(): this is Valid<E, V>;
    isInvalid(): this is Invalid<E, V>;
    errorsOr<T>(alt: T): E[] | T;
    empty<B>(): Validation<E, B[]>;
    concat(val: Validation<E, V[]>): Validation<E, V[]>;
    concatErr<B>(val: Validation<E, B>): Validation<E, B>;
    map<B>(fn: (a: V) => B): Validation<E, B>;
    mapErrors<B>(fn: (e: E[]) => B | B[]): Validation<B, V>;
    mapError<B>(fn: (e: E) => B): Validation<B, V>;
    ap<B>(validation: Validation<E, (a: V) => B>): Validation<E, B>;
    chain<B>(fn: (a: V) => Validation<E, B>): Validation<E, B>;
    fold<B>(fnInvalid: (e: E[], a: V) => B, fnValid: (a: V) => B): B;
    validateEither<E>(either: Either<E | E[], V>): Validation<E, V>;
    validateEitherList<E>(eitherList: Either<E | E[], V>[]): Validation<E, V>;
    validate<E>(validator: (a: V) => Either<E | E[], V>): Validation<E, V>;
    validateAll<E>(validators: ((a: V) => Either<E | E[], V>)[]): Validation<E, V>;
}