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