import { $, $type, Eval, HKT, Kind, TyK, TyVar } from '@fp4ts/core';
import { Eq, Semigroup } from '@fp4ts/cats-kernel';
import { Applicative } from '../applicative';
import { Functor } from '../functor';
import { SemigroupK } from '../semigroup-k';
import { Foldable } from '../foldable';
import { Traversable } from '../traversable';
import { EqK } from '../eq-k';
import { ApplicativeError } from '../applicative-error';
import { Option } from './option';
import { Either } from './either';
import { List, NonEmptyList } from './collections';
import { Bifunctor } from '../bifunctor';
export type Validation<E, A> = _Validation<E, A>;
declare abstract class _Validation<out E, out A> {
    private readonly _E;
    private readonly _A;
    abstract readonly get: A;
    getOrDefault<B>(this: Validation<E, B>, defaultValue: () => B): B;
    abstract readonly getError: ValidationError<E>;
    abstract readonly isValid: boolean;
    abstract readonly isInvalid: boolean;
    get toOption(): Option<A>;
    toEither<E2>(this: Validation<E2, A>, S: Semigroup<E2>): Either<E2, A>;
    toEither(): Either<ValidationError<E>, A>;
    abstract orElse<E2, B>(this: Validation<E2, B>, that: () => Validation<E2, B>): Validation<E2, B>;
    '<|>'<E2, B>(this: Validation<E2, B>, that: () => Validation<E2, B>): Validation<E2, B>;
    abstract map<B>(g: (a: A) => B): Validation<E, B>;
    abstract mapError<E2>(f: (e: E) => E2): Validation<E2, A>;
    bimap<E2, B>(f: (e: E) => E2, g: (a: A) => B): Validation<E2, B>;
    abstract map2<E2, B, C>(this: Validation<E2, A>, that: Validation<E2, B>, f: (a: A, b: B) => C): Validation<E2, C>;
    map2Eval<E2, B, C>(this: Validation<E2, A>, that: Eval<Validation<E2, B>>, f: (a: A, b: B) => C): Eval<Validation<E2, C>>;
    mapN<E2, BS extends unknown[]>(this: Validation<E2, A>, ...thats: {
        [k in keyof BS]: Validation<E2, BS[k]>;
    }): <C>(f: (a: A, ...args: {
        [k in keyof BS]: BS[k];
    }) => C) => Validation<E2, C>;
    product<E2, B>(this: Validation<E2, A>, that: Validation<E2, B>): Validation<E2, [A, B]>;
    abstract andThen<B, E2>(this: Validation<E2, A>, f: (a: A) => Validation<E2, B>): Validation<E2, B>;
    abstract fold<B, C = B>(onFailure: (e: ValidationError<E>) => B, onSuccess: (a: A) => C): B | C;
    traverse<G>(G: Applicative<G>): <B>(f: (a: A) => Kind<G, [B]>) => Kind<G, [Validation<E, B>]>;
    equals<E2, B>(this: Validation<E2, B>, EE: Eq<ValidationError<E2>>, EB: Eq<B>): (that: Validation<E2, B>) => boolean;
}
interface ValidationObj {
    pure<A, E = never>(a: A): Validation<E, A>;
    unit<E = never>(): Validation<E, void>;
    Valid<A, E = never>(a: A): Validation<E, A>;
    Invalid<E, A = never>(ve: ValidationError<E>): Validation<E, A>;
    fail<E, A = never>(e: E): Validation<E, A>;
    tailRecM<S>(s: S): <E, A>(f: (s: S) => Validation<E, Either<S, A>>) => Validation<E, A>;
    fromOption<A, E>(o: Option<A>, onNone: () => E): Validation<E, A>;
    fromEither<A, E>(ea: Either<E, A>): Validation<E, A>;
    EqK<E>(E: Eq<ValidationError<E>>): EqK<$<ValidationF, [E]>>;
    Functor<E>(): Functor<$<ValidationF, [E]>>;
    Bifunctor: Bifunctor<ValidationF>;
    SemigroupK<E>(): SemigroupK<$<ValidationF, [E]>>;
    Applicative<E>(): Applicative<$<ValidationF, [E]>>;
    ApplicativeError<E>(): ApplicativeError<$<ValidationF, [E]>, ValidationError<E>>;
    ApplicativeErrorConcat<E>(E: Semigroup<E>): ApplicativeError<$<ValidationF, [E]>, E>;
    Foldable<E>(): Foldable<$<ValidationF, [E]>>;
    Traversable<E>(): Traversable<$<ValidationF, [E]>>;
}
export declare const Validation: ValidationObj;
export type ValidationError<E> = LiftValidationError<E> | ConcatValidationError<E>;
export declare const ValidationError: ValidationErrorObj;
declare abstract class _ValidationError<E> {
    private readonly _E;
    get toNel(): NonEmptyList<E>;
    get toList(): List<E>;
    map<E2>(f: (e: E) => E2): ValidationError<E2>;
    concat<E2>(this: _ValidationError<E2>, that: ValidationError<E2>): ValidationError<E2>;
    '<>'<E2>(this: _ValidationError<E2>, that: ValidationError<E2>): ValidationError<E2>;
    foldMap<S>(S: Semigroup<S>): (f: (e: E) => S) => S;
    foldS<E2>(this: _ValidationError<E2>, S: Semigroup<E2>): E2;
    equals<E>(E: Eq<E>, that: ValidationError<E>): boolean;
}
declare class LiftValidationError<E> extends _ValidationError<E> {
    readonly error: E;
    readonly tag = "lift";
    constructor(error: E);
}
declare class ConcatValidationError<E> extends _ValidationError<E> {
    readonly lhs: ValidationError<E>;
    readonly rhs: ValidationError<E>;
    readonly tag = "concat";
    constructor(lhs: ValidationError<E>, rhs: ValidationError<E>);
}
interface ValidationErrorObj {
    <E>(e: E): ValidationError<E>;
    Eq: {
        Strict: <E>(E: Eq<E>) => Eq<ValidationError<E>>;
        Concat: <S>(S: Semigroup<S>, SE: Eq<S>) => <E>(f: (e: E) => S) => Eq<ValidationError<E>>;
    };
}
interface _Validation<E, A> extends HKT<ValidationF, [E, A]> {
}
/**
 * @category Type Constructor
 * @category Data
 */
export interface ValidationF extends TyK<[unknown, unknown]> {
    [$type]: Validation<TyVar<this, 0>, TyVar<this, 1>>;
}
export {};
//# sourceMappingURL=validation.d.ts.map