import { $, $type, Eval, HKT, Kind, Lazy, TyK, TyVar } from '@fp4ts/core';
import { Eq, Monoid } from '@fp4ts/cats-kernel';
import { Applicative } from '../applicative';
import { Bifunctor } from '../bifunctor';
import { EqK } from '../eq-k';
import { Monad } from '../monad';
import { MonadError } from '../monad-error';
import { MonoidK } from '../monoid-k';
import { SemigroupK } from '../semigroup-k';
import { Traversable } from '../traversable';
import { List } from './collections';
import { Option } from './option';
export type Either<E, A> = _Either<E, A>;
export declare const Either: EitherObj;
export declare const Left: <E, A = never>(e: E) => Either<E, A>;
export declare const Right: <A, E = never>(a: A) => Either<E, A>;
declare abstract class _Either<out E, out A> {
    private __void;
    private _E;
    private _A;
    abstract readonly isEmpty: boolean;
    get nonEmpty(): boolean;
    get isLeft(): boolean;
    get isRight(): boolean;
    abstract getLeft: E;
    abstract get: A;
    get toOption(): Option<A>;
    get toList(): List<A>;
    get toArray(): A[];
    get swapped(): Either<A, E>;
    fold<B1, B2 = B1>(onLeft: (e: E) => B1, onRight: (a: A) => B2): B1 | B2;
    map<B>(f: (a: A) => B): Either<E, B>;
    tap(f: (a: A) => unknown): Either<E, A>;
    leftMap<E2>(f: (e: E) => E2): Either<E2, A>;
    bimap<E2, B>(f: (e: E) => E2, g: (a: A) => B): Either<E2, B>;
    orElse<E, B>(this: Either<E, B>, that: Lazy<Either<E, B>>): Either<E, B>;
    '<|>'<E2, B>(this: Either<E2, B>, that: Lazy<Either<E2, B>>): Either<E2, B>;
    orElseEval<E2, B>(this: Either<E2, B>, that: Eval<Either<E2, B>>): Eval<Either<E2, B>>;
    getOrElse<A>(this: Either<E, A>, defaultValue: Lazy<A>): A;
    map2<E, B, C>(this: Either<E, A>, that: Either<E, B>, f: (a: A, b: B) => C): Either<E, C>;
    map2Eval<E, B, C>(this: Either<E, A>, that: Eval<Either<E, B>>, f: (a: A, b: B) => C): Eval<Either<E, C>>;
    flatMap<E, B>(this: Either<E, A>, f: (a: A) => Either<E, B>): Either<E, B>;
    leftFlatMap<A, E2>(this: Either<E, A>, f: (e: E) => Either<E2, A>): Either<E2, A>;
    flatten<E, B>(this: Either<E, Either<E, B>>): Either<E, B>;
    foldMap<M>(M: Monoid<M>): (f: (a: A) => M) => M;
    foldMapK<F>(F: MonoidK<F>): <B>(f: (a: A) => Kind<F, [B]>) => Kind<F, [B]>;
    foldLeft<B>(z: B, f: (b: B, a: A) => B): B;
    foldRight<B>(ez: Eval<B>, f: (a: A, eb: Eval<B>) => Eval<B>): Eval<B>;
    traverse<G>(G: Applicative<G>): <B>(f: (a: A) => Kind<G, [B]>) => Kind<G, [Either<E, B>]>;
    equals<E, A>(this: Either<E, A>, that: Either<E, A>, EE?: Eq<E>, EA?: Eq<A>): boolean;
}
interface EitherObj {
    <A, E = never>(a: A): Either<E, A>;
    pure<A, E = never>(a: A): Either<E, A>;
    rightUnit: Either<never, void>;
    tailRecM_<A, E, B>(a0: A, f: (a: A) => Either<E, Either<A, B>>): Either<E, B>;
    Eq<E, A>(EE: Eq<E>, EA: Eq<A>): Eq<Either<E, A>>;
    EqK<E>(EE: Eq<E>): EqK<$<EitherF, [E]>>;
    Bifunctor: Bifunctor<EitherF>;
    SemigroupK<E>(): SemigroupK<$<EitherF, [E]>>;
    Monad<E>(): Monad<$<EitherF, [E]>>;
    MonadError<E>(): MonadError<$<EitherF, [E]>, E>;
    Traversable<E>(): Traversable<$<EitherF, [E]>>;
}
interface _Either<E, A> extends HKT<EitherF, [E, A]> {
}
/**
 * @category Type Constructor
 * @category Data
 */
export interface EitherF extends TyK<[unknown, unknown]> {
    [$type]: Either<TyVar<this, 0>, TyVar<this, 1>>;
}
export {};
//# sourceMappingURL=either.d.ts.map