import { Show } from '../typeclasses/Show';
import { Setoid } from '../typeclasses/Setoid';
import { Ord } from '../typeclasses/Ord';
import { Semigroup } from '../typeclasses/Semigroup';
import { Functor } from '../typeclasses/Functor';
import { Apply } from '../typeclasses/Apply';
import { Applicative } from '../typeclasses/Applicative';
import { Alt } from '../typeclasses/Alt';
import { Chain } from '../typeclasses/Chain';
import { Monad } from '../typeclasses/Monad';
import { Foldable } from '../typeclasses/Foldable';
import { Extend } from '../typeclasses/Extend';
import { Bifunctor } from '../typeclasses/Bifunctor';
import { Unsafe } from '../typeclasses/Unsafe';
import { Maybe } from './Maybe';
export declare type Left<L, R> = Either<L, R>;
export declare type Right<L, R> = Either<L, R>;
export declare type EitherPatterns<L, R, T> = {
    Left: (l: L) => T;
    Right: (r: R) => T;
};
export declare class Either<L, R> implements Show, Setoid<Either<L, R>>, Ord<Either<L, R>>, Semigroup<Either<L, R>>, Functor<R>, Apply<R>, Applicative<R>, Alt<L | R>, Chain<R>, Monad<R>, Foldable<L | R>, Extend<L | R>, Bifunctor<L, R>, Unsafe {
    private readonly value;
    private readonly tag;
    constructor(value: L | R, tag: string);
    readonly of: typeof Either.of;
    readonly 'fantasy-land/alt': (other: Either<L, R>) => Either<L, R>;
    readonly 'fantasy-land/of': typeof Either.of;
    readonly 'fantasy-land/ap': <R2>(other: Either<L, (value: R) => R2>) => Either<L, R2>;
    readonly 'fantasy-land/chain': <R2>(f: (value: R) => Either<L, R2>) => Either<L, R2>;
    readonly 'fantasy-land/reduce': <T>(reducer: (accumulator: T, value: R) => T, initialValue: T) => T;
    readonly 'fantasy-land/map': <R2>(f: (value: R) => R2) => Either<L, R2>;
    readonly 'fantasy-land/lte': (other: Either<L, R>) => boolean;
    readonly 'fantasy-land/extend': <R2>(f: (value: Either<L, R>) => R2) => Either<L, R2>;
    readonly 'fantasy-land/concat': (other: Either<L, R>) => Either<L, R>;
    readonly 'fantasy-land/equals': (other: Either<L, R>) => boolean;
    readonly 'fantasy-land/bimap': <L2, R2>(f: (value: L) => L2, g: (value: R) => R2) => Either<L2, R2>;
    private asLeft();
    private asRight();
    static of<R, L = never>(value: R): Right<L, R>;
    static lefts<L, R>(list: Either<L, R>[]): L[];
    static rights<L, R>(list: Either<L, R>[]): R[];
    static encase<L extends Error, R>(throwsF: () => R): Either<L, R>;
    isLeft(): boolean;
    isRight(): boolean;
    toJSON(): L | R;
    inspect(): string;
    toString(): string;
    bimap<L2, R2>(f: (value: L) => L2, g: (value: R) => R2): Either<L2, R2>;
    map<R2>(f: (value: R) => R2): Either<L, R2>;
    mapLeft<L2>(f: (value: L) => L2): Either<L2, R>;
    ap<R2>(other: Either<L, (value: R) => R2>): Either<L, R2>;
    equals(other: Either<L, R>): boolean;
    lte(other: Either<L, R>): boolean;
    concat(other: Either<L, R>): Either<L, R>;
    chain<R2>(f: (value: R) => Either<L, R2>): Either<L, R2>;
    alt(other: Either<L, R>): Either<L, R>;
    reduce<T>(reducer: (accumulator: T, value: R) => T, initialValue: T): T;
    extend<R2>(f: (value: Either<L, R>) => R2): Either<L, R2>;
    unsafeCoerce(): R;
    caseOf<T>(patterns: EitherPatterns<L, R, T>): T;
    leftOrDefault(defaultValue: L): L;
    orDefault(defaultValue: R): R;
    ifLeft(effect: (value: L) => any): this;
    ifRight(effect: (value: R) => any): this;
    toMaybe(): Maybe<R>;
    leftToMaybe(): Maybe<L>;
    either<T>(ifLeft: (value: L) => T, ifRight: (value: R) => T): T;
    extract(): L | R;
}
export declare const Left: <L, R = never>(value: L) => Either<L, R>;
export declare const Right: <R, L = never>(value: R) => Either<L, R>;