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

A monad for incremental validation without information loss.

import { ValidationShape, Variant } from './ValidationShape';
import Validation, { Either } from './index';
import { Valid } from './Valid';
export declare class Invalid<E, V> implements ValidationShape<E, V> {
    readonly variant: Variant.Invalid;
    readonly errors: E[];
    readonly value: V;
    constructor(value: V, errors: E[]);
    isValid(): this is Valid<E, V>;
    isInvalid(): this is Invalid<E, V>;
    errorsOr<T>(alt: T): T | E[];
    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): Invalid<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(either: Either<E | E[], V>): Validation<E, V>;
    validateEitherList(eitherList: Either<E | E[], V>[]): Validation<E, V>;
    validate(validator: (a: V) => Either<E | E[], V>): Validation<E, V>;
    validateAll(validators: ((a: V) => Either<E | E[], V>)[]): Validation<E, V>;
}