import { default as BiFunctor } from '../../interface/Bifunctor';
import { default as Monad } from '../../interface/Monad';
import { default as PatternMatch } from '../../interface/Patternmatch';
import { default as Setoid } from '../../interface/Setoid';
import { default as Maybe } from '../Maybe';
declare abstract class Either<A, B> implements Setoid, BiFunctor<A, B>, Monad<B>, PatternMatch {
    protected _value: A | B;
    static of<C, D>(v: D): Either<C, D>;
    static Right<C, D>(v: D): Either<C, D>;
    static Left<C, D>(v: C): Either<C, D>;
    static fromNullable<C, D>(v: any): Either<C, D>;
    static withDefault<A, B>(def: B | null | undefined, v: B): Either<A, B>;
    static swap<C, D>(e: Either<C, D>): Either<C, D>;
    static try(f: Function): <C, D>(...args: Array<unknown>) => Either<C, D>;
    static bimap<G, K, C, D>(e: Either<G, K>, fl: (a: G) => C, fr: (b: K) => D): Either<C, D>;
    static isLeft<C, D>(v: Either<C, D>): boolean;
    static isRight<C, D>(v: Either<C, D>): boolean;
    of(v: B): Either<A, B>;
    ap<C, D, E>(j: Either<C, D>): Either<C, E>;
    getValue(): A | B;
    abstract equals(n: Setoid): boolean;
    abstract map<C>(f: (a: B) => C): Either<A, C>;
    abstract bimap<C, D>(fl: (a: A) => C, fr: (a: B) => D): Either<C, D>;
    abstract chain<C>(f: (a: B) => Either<A, C>): Either<A, C>;
    abstract caseOf<T>(o: {
        Left: (a: A) => T;
        Right: (a: B) => T;
    }): T;
    abstract swap(): Either<A, B>;
    abstract isLeft(): boolean;
    abstract isRight(): boolean;
}
export default Either;
export declare const maybeToEither: <A>(m: Maybe<A>) => any;