import * as fluture from "fluture";
export declare class Future<E, D> {
    private instance;
    private constructor();
    run(onSuccess: Fn<D>, onError: Fn<E>): Cancel;
    map<D2>(mapper: (data: D) => D2): Future<E, D2>;
    bimap<E2, D2>(dataMapper: (data: D) => D2, errorMapper: (error: E) => E2): Future<E2, D2>;
    flatMap<D2>(mapper: (data: D) => Future<E, D2>): Future<E, D2>;
    flatMapError<E2>(mapper: (error: E) => Future<E2, D>): Future<E2, D>;
    toPromise(): Promise<D>;
    static fromComputation<E, D>(computation: Computation<E, D>): Future<E, D>;
    static success<D, E = unknown>(data: D): Future<E, D>;
    static error<E, D = unknown>(error: E): Future<E, D>;
    static join2<E, D1, D2>(future1: Future<E, D1>, future2: Future<E, D2>): Future<E, [D1, D2]>;
    static parallel<E, D>(futures: Array<Future<E, D>>, options?: {
        maxConcurrency?: number;
    }): Future<E, Array<D>>;
    static joinObj<FuturesObj extends Record<string, Future<any, any>>>(futuresObj: FuturesObj, options?: {
        maxConcurrency: number;
    }): JoinObj<FuturesObj>;
}
declare type JoinObj<Futures extends Record<string, Future<any, any>>> = Future<ExtractFutureError<Futures[keyof Futures]>, {
    [K in keyof Futures]: ExtractFutureData<Futures[K]>;
}>;
declare type ExtractFutureData<F> = F extends Future<any, infer D> ? D : never;
declare type ExtractFutureError<F> = F extends Future<infer E, any> ? E : never;
declare type Fn<T> = {
    (value: T): void;
};
export declare type Cancel = {
    (): void;
};
export declare const noCancel: Cancel;
export declare type Computation<E, D> = (resolve: Fn<D>, reject: Fn<E>) => fluture.Cancel;
export declare function wait<E>(ms: number): Future<E, void>;
export declare function fromPromise<Data>(res: Promise<Data>): Future<string, Data>;
export {};