import { WhenNever, Cata } from '../Basics';
import Maybe from '../Maybe';
export interface Either<E, T> {
    isLeft(): boolean;
    isRight(): boolean;
    isEqual<E_, T_>(another: Either<WhenNever<E, E_>, WhenNever<T, T_>>): boolean;
    swap(): Either<T, E>;
    map<R>(fn: (value: T) => R): Either<E, R>;
    mapLeft<S>(fn: (error: E) => S): Either<S, T>;
    mapBoth<S, R>(onLeft: (error: E) => S, onRight: (value: T) => R): Either<S, R>;
    chain<E_, R>(fn: (value: T) => Either<WhenNever<E, E_>, R>): Either<WhenNever<E, E_>, R>;
    orElse<E_, T_>(fn: () => Either<WhenNever<E, E_>, WhenNever<T, T_>>): Either<WhenNever<E, E_>, WhenNever<T, T_>>;
    getOrElse<T_>(defaults: WhenNever<T, T_>): WhenNever<T, T_>;
    extract<T_>(fn: (error: E) => WhenNever<T, T_>): WhenNever<T, T_>;
    fold<R>(onLeft: (error: E) => R, onRight: (value: T) => R): R;
    cata<R>(pattern: Pattern<E, T, R>): R;
    toMaybe(): Maybe<T>;
    tap<R>(fn: (that: Either<E, T>) => R): R;
}
export declare namespace Either {
    type Pattern<E, T, R> = Cata<{
        Left(error: E): R;
        Right(value: T): R;
    }>;
    const Left: <E>(error: E) => Either<E, never>;
    const Right: <T>(value: T) => Either<never, T>;
    const fromNullable: <E, T>(error: E, value: T | null | undefined) => Either<E, T extends null | undefined ? never : T>;
    const fromMaybe: <E, T>(error: E, maybe: Maybe<T>) => Either<E, T>;
    const merge: <T>(either: Either<T, T>) => T;
    const shape: <E, O extends {}>(object: { [K in keyof O]: Either<E, O[K]>; }) => Either<E, O>;
    const combine: <E, T>(array: Either<E, T>[]) => Either<unknown extends E ? never : E, (unknown extends T ? never : T)[]>;
}
export declare type Pattern<E, T, R> = Either.Pattern<E, T, R>;
export declare const Left: <E>(error: E) => Either<E, never>;
export declare const Right: <T>(value: T) => Either<never, T>;
export declare const fromNullable: <E, T>(error: E, value: T | null | undefined) => Either<E, T extends null | undefined ? never : T>;
export declare const fromMaybe: <E, T>(error: E, maybe: Maybe<T>) => Either<E, T>;
export declare const merge: <T>(either: Either<T, T>) => T;
export declare const shape: <E, O extends {}>(object: { [K in keyof O]: Either<E, O[K]>; }) => Either<E, O>;
export declare const combine: <E, T>(array: Either<E, T>[]) => Either<unknown extends E ? never : E, (unknown extends T ? never : T)[]>;
export default Either;