import { Result } from "./OptionResult";
import { LooseRecord } from "./types";
export declare class __Future<A> {
    /**
     * Creates a new future from its initializer function (like `new Promise(...)`)
     */
    static make: <A_1>(init: (resolver: (value: A_1) => void) => (() => void) | void) => Future<A_1>;
    static isFuture: (value: unknown) => value is Future<unknown>;
    /**
     * Creates a future resolved to the passed value
     */
    static value: <A_1>(value: A_1) => Future<A_1>;
    /**
     * Converts a Promise to a Future\<Result\<Value, unknown>>
     */
    static fromPromise<A, E = unknown>(promise: Promise<A>): Future<Result<A, E>>;
    /**
     * Turns an array of futures into a future of array
     */
    static all: <const Futures extends [] | readonly Future<any>[]>(futures: Futures, propagateCancel?: boolean) => Future<{ [K in keyof Futures]: Futures[K] extends Future<infer T> ? T : never; }>;
    /**
     * Turns an dict of futures into a future of dict
     */
    static allFromDict: <const Dict extends LooseRecord<Future<any>>>(dict: Dict) => Future<{ [K in keyof Dict]: Dict[K] extends Future<infer T> ? T : never; }>;
    static wait: (ms: number) => Future<void>;
    static retry: <A_1, E>(getFuture: (attempt: number) => Future<Result<A_1, E>>, { max }: {
        max: number;
    }) => Future<Result<A_1, E>>;
    static concurrent: <const Futures extends readonly (() => Future<any>)[]>(array: Futures, { concurrency }: {
        concurrency: number;
    }) => Future<{ [K in keyof Futures]: Futures[K] extends () => Future<infer T> ? T : never; }>;
    private _state;
    protected constructor();
    /**
     * Runs the callback with the future value when resolved
     */
    onResolve(func: (value: A) => void): void;
    /**
     * Runs the callback if and when the future is cancelled
     */
    onCancel(func: () => void): void;
    /**
     * Cancels the future
     */
    cancel(): void;
    /**
     * Returns the Future containing the value from the callback
     *
     * (Future\<A>, A => B) => Future\<B>
     */
    map<B>(func: (value: A) => B, propagateCancel?: boolean): Future<B>;
    then(func: (value: A) => void): this;
    /**
     * Returns the Future containing the value from the callback
     *
     * (Future\<A>, A => Future\<B>) => Future\<B>
     */
    flatMap<B>(func: (value: A) => Future<B>, propagateCancel?: boolean): Future<B>;
    /**
     * Runs the callback and returns `this`
     */
    tap(this: Future<A>, func: (value: A) => unknown): Future<A>;
    /**
     * For Future<Result<*>>:
     *
     * Runs the callback with the value if ok and returns `this`
     */
    tapOk<A, E>(this: Future<Result<A, E>>, func: (value: A) => unknown): Future<Result<A, E>>;
    /**
     * For Future<Result<*>>:
     *
     * Runs the callback with the error if in error and returns `this`
     */
    tapError<A, E>(this: Future<Result<A, E>>, func: (value: E) => unknown): Future<Result<A, E>>;
    /**
     * For Future<Result<*>>:
     *
     * Takes a callback taking the Ok value and returning a new result and returns a future resolving to this new result
     */
    mapOkToResult<A, E, B, F>(this: Future<Result<A, E>>, func: (value: A) => Result<B, F>, propagateCancel?: boolean): Future<Result<B, F | E>>;
    /**
     * For Future<Result<*>>:
     *
     * Takes a callback taking the Error value and returning a new result and returns a future resolving to this new result
     */
    mapErrorToResult<A, E, B, F>(this: Future<Result<A, E>>, func: (value: E) => Result<B, F>, propagateCancel?: boolean): Future<Result<A | B, F>>;
    /**
     * For Future<Result<*>>:
     *
     * Takes a callback taking the Ok value and returning a new ok value and returns a future resolving to this new result
     */
    mapOk<A, E, B>(this: Future<Result<A, E>>, func: (value: A) => B, propagateCancel?: boolean): Future<Result<B, E>>;
    /**
     * For Future<Result<*>>:
     *
     * Takes a callback taking the Error value and returning a new error value and returns a future resolving to this new result
     */
    mapError<A, E, B>(this: Future<Result<A, E>>, func: (value: E) => B, propagateCancel?: boolean): Future<Result<A, B>>;
    /**
     * For Future<Result<*>>:
     *
     * Takes a callback taking the Ok value and returning a future
     */
    flatMapOk<A, E, B, F>(this: Future<Result<A, E>>, func: (value: A) => Future<Result<B, F>>, propagateCancel?: boolean): Future<Result<B, F | E>>;
    /**
     * For Future<Result<*>>:
     *
     * Takes a callback taking the Error value and returning a future
     */
    flatMapError<A, E, B, F>(this: Future<Result<A, E>>, func: (value: E) => Future<Result<B, F>>, propagateCancel?: boolean): Future<Result<A | B, F>>;
    /**
     * Converts the future into a promise
     */
    toPromise(): Promise<A>;
    /**
     * For Future<Result<*>>:
     *
     * Converts the future into a promise (rejecting if in Error)
     */
    resultToPromise<A, E>(this: Future<Result<A, E>>): Promise<A>;
}
export declare const Future: typeof __Future;
export type Future<A> = __Future<A>;