import { Cata, WhenNever } from '../Basics';
import Maybe from '../Maybe';
import Either from '../Either';
import { RemoteData } from './index';
export interface Optional<E, T> extends RemoteData<E, T> {
    isNotAsked(): boolean;
    isEqual<E_, T_>(another: Optional<WhenNever<E, E_>, WhenNever<T, T_>>): boolean;
    swap(): Optional<T, E>;
    map<R>(fn: (value: T) => R): Optional<E, R>;
    mapFailure<S>(fn: (error: E) => S): Optional<S, T>;
    mapBoth<S, R>(onFailure: (error: E) => S, onSucceed: (value: T) => R): Optional<S, R>;
    chain<E_, R>(fn: (value: T) => Optional<WhenNever<E, E_>, R>): Optional<WhenNever<E, E_>, R>;
    orElse<E_, T_>(fn: () => Optional<WhenNever<E, E_>, WhenNever<T, T_>>): Optional<WhenNever<E, E_>, WhenNever<T, T_>>;
    cata<R>(pattern: Optional.Pattern<E, T, R>): R;
    tap<R>(fn: (that: Optional<E, T>) => R): R;
}
export declare namespace Optional {
    type Pattern<E, T, R> = Cata<{
        NotAsked(): R;
        Loading(): R;
        Failure(error: E): R;
        Succeed(value: T): R;
    }>;
    const NotAsked: Optional<never, never>;
    const Loading: Optional<never, never>;
    const Failure: <E>(error: E) => Optional<E, never>;
    const Succeed: <T>(value: T) => Optional<never, T>;
    const fromMaybe: <E, T>(error: E, maybe: Maybe<T>) => Optional<E, T>;
    const fromEither: <E, T>(either: Either<E, T>) => Optional<E, T>;
    const shape: <E, O extends {}>(object: { [K in keyof O]: Optional<E, O[K]>; }) => Optional<E, O>;
    const combine: <E, T>(array: Optional<E, T>[]) => Optional<unknown extends E ? never : E, (unknown extends T ? never : T)[]>;
}
export declare type Pattern<E, T, R> = Optional.Pattern<E, T, R>;
export declare const NotAsked: Optional<never, never>;
export declare const Loading: Optional<never, never>;
export declare const Failure: <E>(error: E) => Optional<E, never>;
export declare const Succeed: <T>(value: T) => Optional<never, T>;
export declare const fromMaybe: <E, T>(error: E, maybe: Maybe<T>) => Optional<E, T>;
export declare const fromEither: <E, T>(either: Either<E, T>) => Optional<E, T>;
export declare const shape: <E, O extends {}>(object: { [K in keyof O]: Optional<E, O[K]>; }) => Optional<E, O>;
export declare const combine: <E, T>(array: Optional<E, T>[]) => Optional<unknown extends E ? never : E, (unknown extends T ? never : T)[]>;
export default Optional;