import Traversable from "../../specifications/Traversable";
import Bifunctor from "../../specifications/Bifunctor";
import Monad from "../../specifications/Monad";
import { Applicative, ApplicativeTypeRep } from "../../specifications/Applicative";
import { FNA1 } from "../../specifications/Function";
export default abstract class Either<L, R> implements Monad<R>, Bifunctor<L, R>, Traversable<R> {
    protected constructor();
    abstract map<R2>(fn: (a: R) => R2): Either<L, R2>;
    abstract ap<R2>(other: Either<any, R2>): R extends FNA1<R2, infer R3> ? Either<L, R3> : Either<any, any>;
    abstract chain<R2>(fn: (right: R) => Either<L, R2>): Either<L, R2>;
    static of<L, R>(right: R): Either<L, R>;
    abstract bimap<L2, R2>(fnLeft: (left: L) => L2, fnRight: (right: R) => R2): Either<L2, R2>;
    abstract mapLeft<L2>(fn: (left: L) => L2): Either<L2, R>;
    abstract reduce<R2>(reducer: (accumulator: R2, value: R) => R2, initial: R2): R2;
    abstract traverse<R2>(TypeRep: ApplicativeTypeRep<Either<L, R2>>, fn: (a: R) => Applicative<R2>): Applicative<Either<L, R2>>;
    abstract get(): L | R;
    abstract getOrElse(other: R): R;
    static right<L, R>(right: R): Right<L, R>;
    static left<L, R>(left: L): Left<L, R>;
    abstract swap(): Either<R, L>;
    get isRight(): Boolean;
    get isLeft(): Boolean;
    abstract inspect(): string;
}
declare class Left<L, R> extends Either<L, R> {
    private readonly value;
    constructor(value: L);
    map<R2>(fn: (a: R) => R2): Left<L, R2>;
    ap<R2>(other: Either<any, R2>): R extends FNA1<R2, infer R3> ? Either<L, R3> : Either<any, any>;
    chain<R2>(fn: (right: R) => Either<L, R2>): Either<L, R2>;
    bimap<L2, R2>(fnLeft: (left: L) => L2, fnRight: (right: R) => R2): Left<L2, R2>;
    reduce<R2>(reducer: (accumulator: R2, value: R) => R2, initial: R2): R2;
    traverse<R2>(TypeRep: ApplicativeTypeRep<Either<L, R2>>, fn: (a: R) => Applicative<R2>): Applicative<Either<L, R2>>;
    mapLeft<L2>(fn: (left: L) => L2): Left<L2, R>;
    join(): Either<L, R>;
    get(): L;
    getOrElse(other: R): R;
    swap(): Either<R, L>;
    get isLeft(): Boolean;
    inspect(): string;
}
declare class Right<L, R> extends Either<L, R> {
    private readonly value;
    constructor(value: R);
    map<R2>(fn: (a: R) => R2): Either<L, R2>;
    ap<R2>(other: Either<any, R2>): R extends FNA1<R2, infer R3> ? Either<L, R3> : Either<any, any>;
    chain<R2>(fn: (right: R) => Either<L, R2>): Either<L, R2>;
    bimap<L2, R2>(fnLeft: (left: L) => L2, fnRight: (right: R) => R2): Right<L2, R2>;
    mapLeft<L2>(fn: (left: L) => L2): Either<L2, R>;
    reduce<R2>(reducer: (accumulator: R2, value: R) => R2, initial: R2): R2;
    traverse<R2>(TypeRep: ApplicativeTypeRep<Either<L, R2>>, fn: (a: R) => Applicative<R2>): Applicative<Either<L, R2>>;
    join(): Either<L, R | any>;
    get(): R;
    getOrElse(other: R): R;
    swap(): Either<R, L>;
    get isRight(): Boolean;
    inspect(): string;
}
export {};