/**
 * A Future is a primitive for managing asynchronous side-effects in an
 * organized manner.
 *
 * It works by queuing up the async tasks in a monad like chain, only executing
 * them when the instruction to do so is given. This is in contrast to the
 * Promise which executes these side-effects as soon as it is created. A Future
 * is easier to reason about than a Promise and allows async code to be more
 * composable. To allow Futures to benefit from the JS engine's built in Promise
 * support however, Futures also implement the Promise api.
 */
import { Type } from '../../data/type';
import { Milliseconds } from '../time';
import { Err, Except } from '../error';
import { Monad } from './';
/**
 * Yield is a value that may be itself or may be wrapped in a [[Future]].
 *
 * This is type is used to represent return values of functions that may be
 * async or not for situations where it may be desirable to have the. Care
 * should be used when handling these values as it is easy to forget to fork()
 * the Future resulting in incorrect values being passed around.
 *
 * Use the [[wrap]] before attempting to process a Yield to be on the safe side.
 */
export type Yield<T> = T | Future<T>;
/**
 * OnError callback function type.
 */
export type OnError = (e: Error) => void;
/**
 * OnSuccess callback function type.
 */
export type OnSuccess<A> = (a: A) => void;
/**
 * Aborter callback function type.
 */
export type Aborter = () => void;
/**
 * ErrorHandler callback function type.
 *
 * These are used to trap and recover from errors.
 */
export type ErrorHandler<A> = (e: Error) => Future<A>;
/**
 * Finalizer callback function type.
 *
 * Finalizers can be used to clean up resources etc.
 */
export type Finalizer<A> = () => Future<A>;
/**
 * NodeFunction is a node platform async function.
 */
export type NodeFunction = <A>(f: (cb: Callback<A>) => void) => void;
/**
 * Task is the type of functions that execute async work via a Promise.
 */
export type Task<A> = () => Promise<A>;
/**
 * Callback in node platform style for asynchronous effects.
 */
export type Callback<A> = (e: Error | undefined | null, a?: A) => void;
/**
 * CallBackReceiver type takes a node style callback
 * and performs some side-effect.
 */
export type CallbackReceiver<A> = (cb: Callback<A>) => void;
/**
 * Reducer function type.
 */
export type Reducer<A, B> = (p: B, c: A, i: number) => Future<B>;
/**
 * FutureFunc function type.
 */
export type FutureFunc<A, B> = (a: A) => Future<B>;
/**
 * ResolveFunc for promises.
 */
export type ResolveFunc<A, TResult1 = A> = ((value: A) => TResult1 | PromiseLike<TResult1>) | undefined | null;
/**
 * RejectFunc for promises.
 */
export type RejectFunc<TResult2 = never> = ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null;
/**
 * CatchFunc
 */
export type CatchFunc<A> = (reason: any) => A | PromiseLike<A>;
/**
 * Future represents a chain of asynchronous tasks that some result when
 * executed.
 *
 * The Future implementation is different that a Promise as it does not
 * execute it's tasks until instructed to giving control back to the calling
 * code (unlike Promises). To accomplish this, a state machine is built up
 * from the various calls to chain(), map() etc and executed in the run()
 * method.
 *
 * To make using this API easier, doFuture() is provided which allows chains
 * of Futures to be created without callback hell via generators. Use the run()
 * method to get a Promise that contains the final value or treat the future
 * itself as a Promise (calling then() also executes the Future).
 *
 * @typeParam A - The type of the final value.
 */
export declare abstract class Future<A> implements Monad<A>, Promise<A> {
    tag: string;
    /**
     * @param tag - Used internally to distinguish Future types.
     */
    constructor(tag?: string);
    /**
     * of wraps a pure value in a Future.
     */
    static of<A>(a: A): Future<A>;
    /**
     * do notation for Futures using async functions.
     *
     * An async function executes its body sequentially, pausing at each 'await'
     * statement preventing asynchronous tasks from pre-empting each other. This
     * is in line with how Futures are meant to work and could be seen as the
     * Promise equivalent of:
     *
     * ```
     *  pure().chain(task1).chain(task2).chain(task3);
     * ```
     * The difference between Futures and promises of course, is that Futures do
     * not execute their tasks until fork() is called whereas Promises are
     * immediate. Nonetheless, an async function can be treated as a Future
     * because it does not execute any code until it is called.
     *
     * This static method may therfore be more desirable than doFuture() as it
     * allows for the use of arrow functions doing await with the need to set
     * `this` to a variable.
     */
    static do<A>(fun: Task<A>): Future<A>;
    /**
     * raise wraps an Error in a Future.
     *
     * This future will be considered a failure.
     */
    static raise: <A_1>(e: Err) => Future<A_1>;
    /**
     * fromCallback produces a Future from a node style async function.
     */
    static fromCallback: <A_1>(f: CallbackReceiver<A_1>) => Future<A_1>;
    /**
     * parallel runs a list of Futures in parallel failing if any
     * fail and succeeding with a list of successful values.
     */
    static parallel: <A_1>(list: Future<A_1>[]) => Future<A_1[]>;
    /**
     * sequential execution of a list of futures.
     *
     * This function succeeds with a list of all results or fails on the first
     * error.
     */
    static sequential: <A_1>(list: Future<A_1>[]) => Future<A_1[]>;
    /**
     * batch runs a list of batched Futures one batch at a time.
     */
    static batch: <A_1>(list: Future<A_1>[][]) => Future<A_1[][]>;
    /**
     * reduce a list of values into a single value using a reducer function that
     * produces a Future.
     */
    static reduce: <A_1, B>(list: A_1[], initValue: B, f: Reducer<A_1, B>) => Future<B>;
    /**
     * race given a list of Futures, will return a Future that is settled by
     * the first error or success to occur.
     *
     * Raising an error if the list is empty.
     */
    static race: <A_1>(list: Future<A_1>[]) => Future<A_1>;
    /**
     * some executes a list of Futures sequentially until one resolves with a
     * successful value.
     *
     * If none resolve successfully, the final error is raised.
     */
    static some: <A_1>(list: Future<A_1>[]) => Future<A_1>;
    /**
     * liftSync wraps a synchronous function in a Future.
     */
    static liftSync: <A_1>(f: () => A_1) => Future<A_1>;
    get [Symbol.toStringTag](): string;
    of(a: A): Future<A>;
    map<B>(f: (a: A) => B): Future<B>;
    ap<B>(ft: Future<(a: A) => B>): Future<B>;
    chain<B>(f: (a: A) => Future<B>): Future<B>;
    trap<B>(f: (e: Error) => Future<B>): Future<B>;
    finish<B>(f: () => Future<B>): Future<B>;
    then<TResult1 = A, TResult2 = never>(onResolve?: ResolveFunc<A, TResult1>, onReject?: RejectFunc<TResult2>): Promise<TResult1 | TResult2>;
    catch<B = never>(f: CatchFunc<B> | undefined | null): Promise<B>;
    finally(f: () => void | undefined | null): Promise<A>;
    /**
     * fork triggers the asynchronous execution of the Future passing the
     * result or error to the provided callbacks.
     */
    fork(onError?: OnError, onSuccess?: OnSuccess<A>): void;
    /**
     * run this Future triggering execution of its asynchronous work.
     */
    run(): Promise<A>;
}
/**
 * Pure constructor.
 */
export declare class Pure<A> extends Future<A> {
    value: A;
    constructor(value: A);
    map<B>(f: (a: A) => B): Future<B>;
    ap<B>(ft: Future<(a: A) => B>): Future<B>;
}
/**
 * Bind constructor.
 * @internal
 */
export declare class Bind<A, B> extends Future<B> {
    target: Future<A>;
    func: (a: A) => Future<B>;
    constructor(target: Future<A>, func: (a: A) => Future<B>);
}
/**
 * Call constructor.
 * @internal
 */
export declare class Call<A> extends Future<A> {
    target: (a: A) => Future<A>;
    constructor(target: (a: A) => Future<A>);
}
/**
 * Catch constructor.
 * @internal
 */
export declare class Catch<A, B> extends Future<B> {
    target: Future<A>;
    func: (e: Error) => Future<B>;
    constructor(target: Future<A>, func: (e: Error) => Future<B>);
}
/**
 * Finally constructor.
 * @internal
 */
export declare class Finally<A, B> extends Future<B> {
    target: Future<A>;
    func: () => Future<B>;
    constructor(target: Future<A>, func: () => Future<B>);
}
/**
 * Trap constructor.
 * @internal
 */
export declare class Trap<A> extends Future<A> {
    func: (e: Error) => Future<A>;
    constructor(func: (e: Error) => Future<A>);
}
/**
 * Raise constructor.
 */
export declare class Raise<A> extends Future<A> {
    value: Err;
    constructor(value: Err);
    map<B>(_: (a: A) => B): Future<B>;
    ap<B>(_: Future<(a: A) => B>): Future<B>;
    chain<B>(_: (a: A) => Future<B>): Future<B>;
}
/**
 * Run constructor.
 * @internal
 */
export declare class Run<A> extends Future<A> {
    task: Task<A>;
    constructor(task: Task<A>);
}
/**
 * Generation constructor.
 *
 * @internal
 */
export declare class Generation<A> extends Future<A> {
    src: Generator<Future<Type>, Future<A>, Type>;
    constructor(src: Generator<Future<Type>, Future<A>, Type>);
}
/**
 * @internal
 */
export declare class Tag<A> {
    index: number;
    value: A;
    constructor(index: number, value: A);
}
/**
 * voidPure is a Future that provides the absence of a value for your
 * convenience.
 */
export declare const voidPure: Future<void>;
/**
 * wrap a value in a Future returning the value if the value is itself a Future.
 */
export declare const wrap: <A>(a: A | Future<A>) => Future<A>;
/**
 * run sets up an async task to be executed at a later point.
 */
export declare const run: <A>(task: Task<A>) => Future<A>;
export { run as liftP };
/**
 * delay execution of a function f after n milliseconds have passed.
 *
 * Any errors thrown are caught and processed in the Future chain.
 */
export declare const delay: <A>(f: () => A, n?: Milliseconds) => Future<A>;
/**
 * wait n milliseconds before continuing the Future chain.
 */
export declare const wait: (n?: Milliseconds) => Future<void>;
export declare const pure: typeof Future.of;
export declare const fromCallback: <A>(f: CallbackReceiver<A>) => Future<A>;
export declare const parallel: <A>(list: Future<A>[]) => Future<A[]>;
export declare const sequential: <A>(list: Future<A>[]) => Future<A[]>;
export declare const batch: <A>(list: Future<A>[][]) => Future<A[][]>;
export declare const reduce: <A, B>(list: A[], initValue: B, f: Reducer<A, B>) => Future<B>;
export declare const race: <A>(list: Future<A>[]) => Future<A>;
export declare const some: <A>(list: Future<A>[]) => Future<A>;
export declare const raise: <A>(e: Err) => Future<A>;
export declare const attempt: <A>(f: () => A) => Future<A>;
/**
 * toPromise transforms a Future into a Promise.
 *
 * This function depends on the global promise constructor and
 * will fail if the environment does not provide one.
 *
 * @deprecated
 */
export declare const toPromise: <A>(ft: Future<A>) => Promise<A>;
/**
 * fromExcept converts an Except to a Future.
 */
export declare const fromExcept: <A>(e: Except<A>) => Future<A>;
/**
 * @internal
 * TODO: Remove Type usage.
 */
export type DoFutureGenerator<A> = () => Generator<Future<Type>, Future<A>, Type>;
/**
 * doFuture allows for multiple Futures to be chained together in an almost
 * monadic fashion via a generator function.
 *
 * Each Future yielded from the generator is executed sequentially with results
 * made available via the Generator#next() method. Raise values trigger an
 * internal error handling mechanism and can be caught via try/catch clauses
 * in the generator.
 *
 * Note: due to the lazy nature of how Futures are evaluated, try/catch will not
 * intercept a Raise used with a return statement. At that point the generator
 * is already complete and that Raise must be handled by the calling code if
 * desired. Alternatively, you can yield the final Future instead of returning
 * it. That way it can be intercepted by the try/catch.
 *
 * @deprecated
 */
export declare const doFuture: <A>(f: DoFutureGenerator<A>) => Future<A>;