import { WhenNever } from '../Basics';
import Maybe from '../Maybe';
import { Optional } from './Optional';
declare abstract class RemoteData<E, T> implements Optional<E, T> {
    isNotAsked(): boolean;
    isLoading(): boolean;
    isFailure(): boolean;
    isSucceed(): boolean;
    abstract 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_>>;
    getOrElse<T_>(defaults: WhenNever<T, T_>): WhenNever<T, T_>;
    abstract cata<R>(pattern: Optional.Pattern<E, T, R>): R;
    toMaybe(): Maybe<T>;
    tap<R>(fn: (that: Optional<E, T>) => R): R;
}
export declare const NotAsked: {
    isNotAsked(): boolean;
    isEqual(another: Optional<never, never>): boolean;
    cata<R>(pattern: {
        NotAsked: () => R;
        Loading: () => R;
        Failure: (error: never) => R;
        Succeed: (value: never) => R;
        _?: (() => never) | undefined;
    } | {
        NotAsked?: (() => R) | undefined;
        Loading?: (() => R) | undefined;
        Failure?: ((error: never) => R) | undefined;
        Succeed?: ((value: never) => R) | undefined;
        _: () => R;
    }): R;
    isLoading(): boolean;
    isFailure(): boolean;
    isSucceed(): boolean;
    swap(): Optional<never, never>;
    map<R>(_fn: (value: never) => R): Optional<never, R>;
    mapFailure<S>(_fn: (error: never) => S): Optional<S, never>;
    mapBoth<S, R>(onFailure: (error: never) => S, onSucceed: (value: never) => R): Optional<S, R>;
    chain<E_, R>(_fn: (value: never) => Optional<WhenNever<never, E_>, R>): Optional<WhenNever<never, E_>, R>;
    orElse<E_, T_>(fn: () => Optional<WhenNever<never, E_>, WhenNever<never, T_>>): Optional<WhenNever<never, E_>, WhenNever<never, T_>>;
    getOrElse<T_>(defaults: WhenNever<never, T_>): WhenNever<never, T_>;
    toMaybe(): Maybe<never>;
    tap<R>(fn: (that: Optional<never, never>) => R): R;
};
export declare const Loading: {
    isLoading(): boolean;
    isEqual(another: Optional<never, never>): boolean;
    cata<R>(pattern: {
        NotAsked: () => R;
        Loading: () => R;
        Failure: (error: never) => R;
        Succeed: (value: never) => R;
        _?: (() => never) | undefined;
    } | {
        NotAsked?: (() => R) | undefined;
        Loading?: (() => R) | undefined;
        Failure?: ((error: never) => R) | undefined;
        Succeed?: ((value: never) => R) | undefined;
        _: () => R;
    }): R;
    isNotAsked(): boolean;
    isFailure(): boolean;
    isSucceed(): boolean;
    swap(): Optional<never, never>;
    map<R>(_fn: (value: never) => R): Optional<never, R>;
    mapFailure<S>(_fn: (error: never) => S): Optional<S, never>;
    mapBoth<S, R>(onFailure: (error: never) => S, onSucceed: (value: never) => R): Optional<S, R>;
    chain<E_, R>(_fn: (value: never) => Optional<WhenNever<never, E_>, R>): Optional<WhenNever<never, E_>, R>;
    orElse<E_, T_>(fn: () => Optional<WhenNever<never, E_>, WhenNever<never, T_>>): Optional<WhenNever<never, E_>, WhenNever<never, T_>>;
    getOrElse<T_>(defaults: WhenNever<never, T_>): WhenNever<never, T_>;
    toMaybe(): Maybe<never>;
    tap<R>(fn: (that: Optional<never, never>) => R): R;
};
export declare class Failure<E> extends RemoteData<E, never> {
    private readonly error;
    constructor(error: E);
    isFailure(): boolean;
    isEqual<E_>(another: Optional<WhenNever<E, E_>, never>): boolean;
    swap(): Optional<never, E>;
    mapFailure<S>(fn: (error: E) => S): Optional<S, never>;
    cata<R>(pattern: Optional.Pattern<E, never, R>): R;
}
export declare class Succeed<T> extends RemoteData<never, T> {
    private readonly value;
    constructor(value: T);
    isSucceed(): boolean;
    isEqual<T_>(another: Optional<never, WhenNever<T, T_>>): boolean;
    swap(): Optional<T, never>;
    map<R>(fn: (value: T) => R): Optional<never, R>;
    chain<R>(fn: (value: T) => Optional<never, R>): Optional<never, R>;
    orElse<T_>(): Optional<never, WhenNever<T, T_>>;
    getOrElse<T_>(): WhenNever<T, T_>;
    cata<R>(pattern: Optional.Pattern<never, T, R>): R;
}
export {};