declare type Predicate<P, E> = (p: P) => Validated<E, unknown>;
export declare type ErrorOfValidated<V> = V extends Invalid<infer E, any> ? E : never;
declare type ErrorOfCombinedValidated<O> = Partial<{
    [K in keyof O]: ErrorOfValidated<O[K]>;
}>;
export declare type ValueOfValidated<V> = V extends Valid<any, infer A> ? A : never;
declare type ValueOfCombinedValidated<O> = {
    [K in keyof O]: ValueOfValidated<O[K]>;
};
declare type ObjectToCombine = {
    [k: string]: Validated<any, any>;
};
export declare type CombinedValidated<O> = Validated<ErrorOfCombinedValidated<O>, ValueOfCombinedValidated<O>>;
export declare type Validated<E, A = []> = Invalid<E, A> | Valid<E, A>;
export declare abstract class AbstractValidated<E, A = []> {
    map<B>(f: (a: A) => B): Validated<E, B>;
    mapError<F>(f: (error: E) => F): Validated<F, A>;
    flatMap<F, B>(f: (a: A) => Validated<F, B>): Validated<E | F, B>;
    filter<F>(pred: (a: A) => boolean, toError: (error: A) => F): Validated<E | F, A>;
    test<F>(...predicates: Array<Predicate<A, F>>): Validated<E | F[], A>;
    recover<B>(f: (error: E) => B): Validated<never, A | B>;
    orElse<F, B>(alternative: Validated<F, B>): Validated<F, A | B>;
    abstract isValid(): this is Valid<E, A>;
    isInvalid(): this is Invalid<E, A>;
    abstract fold<B>(ok: (a: A) => B, error: (error: E) => B): B;
}
declare function ok(): Valid<never, []>;
declare function ok<A>(value: A): Valid<never, A>;
export declare const Validated: {
    ok: typeof ok;
    error<E>(error: E): Invalid<E, never>;
    sequence<E, A>(validateds: Validated<E, A>[]): Validated<(E | undefined)[], A[]>;
    combine<O extends ObjectToCombine>(o: O): Validated<Partial<{ [K in keyof O]: ErrorOfValidated<O[K]>; }>, ValueOfCombinedValidated<O>>;
};
export declare class Valid<E, A> extends AbstractValidated<E, A> {
    readonly value: A;
    static readonly type = "valid";
    constructor(value: A);
    fold<B>(ok: (a: A) => B, _error: (error: never) => B): B;
    isValid(): this is Valid<E, A>;
}
export declare class Invalid<E, A> extends AbstractValidated<E, A> {
    readonly error: E;
    static readonly type = "invalid";
    constructor(error: E);
    fold<B>(_ok: (a: A) => B, error: (error: E) => B): B;
    isValid(): this is Valid<E, A>;
}
export {};