import { WhenNever } from '../Basics';
import Maybe from '../Maybe';
import { Either as IEither, Pattern } from './index';
declare abstract class Either<E, T> implements IEither<E, T> {
    isLeft(): boolean;
    isRight(): boolean;
    abstract isEqual<E_, T_>(another: IEither<WhenNever<E, E_>, WhenNever<T, T_>>): boolean;
    abstract swap(): IEither<T, E>;
    map<R>(_fn: (value: T) => R): IEither<E, R>;
    mapLeft<S>(_fn: (error: E) => S): IEither<S, T>;
    mapBoth<S, R>(onLeft: (error: E) => S, onRight: (value: T) => R): IEither<S, R>;
    chain<E_, R>(_fn: (value: T) => IEither<WhenNever<E, E_>, R>): IEither<WhenNever<E, E_>, R>;
    orElse<E_, T_>(fn: () => IEither<WhenNever<E, E_>, WhenNever<T, T_>>): IEither<WhenNever<E, E_>, WhenNever<T, T_>>;
    getOrElse<T_>(defaults: WhenNever<T, T_>): WhenNever<T, T_>;
    abstract extract<T_>(fn: (error: E) => WhenNever<T, T_>): WhenNever<T, T_>;
    abstract fold<R>(onLeft: (error: E) => R, onRight: (value: T) => R): R;
    abstract cata<R>(pattern: Pattern<E, T, R>): R;
    toMaybe(): Maybe<T>;
    tap<R>(fn: (that: Either<E, T>) => R): R;
}
export declare class Left<E> extends Either<E, never> {
    private readonly error;
    constructor(error: E);
    isLeft(): boolean;
    isEqual<E_>(another: IEither<WhenNever<E, E_>, never>): boolean;
    mapLeft<S>(fn: (error: E) => S): IEither<S, never>;
    swap(): IEither<never, E>;
    extract<T>(fn: (error: E) => T): T;
    fold<R>(onLeft: (error: E) => R): R;
    cata<R>(pattern: Pattern<E, never, R>): R;
}
export declare class Right<T> extends Either<never, T> {
    private readonly value;
    constructor(value: T);
    isRight(): boolean;
    isEqual<T_>(another: IEither<never, WhenNever<T, T_>>): boolean;
    map<R>(fn: (value: T) => R): IEither<never, R>;
    chain<R>(fn: (value: T) => IEither<never, R>): IEither<never, R>;
    orElse<T_>(): IEither<never, WhenNever<T, T_>>;
    getOrElse<T_>(): WhenNever<T, T_>;
    swap(): IEither<T, never>;
    extract<T_>(): WhenNever<T, T_>;
    fold<R>(_onLeft: (error: never) => R, onRight: (value: T) => R): R;
    cata<R>(pattern: Pattern<never, T, R>): R;
}
export {};