import { Validation } from "../util";
export declare type Reject<E> = (error: E) => void;
export declare type Resolve<S> = (result: S) => void;
export declare type Fork<E, S> = (reject: Reject<E>, resolve: Resolve<S>) => void;
/**
 * Creates a Task which can be resolved/rejected externally.
 */
export declare const external: <E, S>() => ExternalTask<E, S>;
export declare const emitter: <Args extends unknown[], R>(fn: (...args: Args) => R) => [ExternalTask<unknown, R>, (...args: Args) => void];
/**
 * Creates a Task which has already successfully completed with `result`.
 * @alias of
 * @alias ok
 * @param result The value to place into the successful Task.
 */
export declare const succeed: <S>(result: S) => Task<never, S>;
export declare const of: <S>(result: S) => Task<never, S>;
/**
 * Creates a Task which succeeds when forked.
 * @param result The function which will produce the result.
 */
export declare const succeedBy: <S>(result: () => S) => Task<unknown, S>;
export declare const try_: <S>(result: () => S) => Task<unknown, S>;
/**
 * Creates a Task has an empty result.
 * @alias unit
 */
export declare const empty: () => Task<never, undefined>;
/**
 * Creates a Task which automatically succeeds at some time in the future with `result`.
 * @param ms How many milliseconds until it succeeds.
 * @param result The value to place into the successful Task.
 */
export declare const succeedIn: <S>(ms: number, result: S) => Task<never, S>;
/**
 * Creates a Task which has already failed with `error`.
 * @alias err
 * @param error The error to place into the failed Task.
 */
export declare const fail: <E>(error: E) => Task<E, never>;
/**
 * Creates a Task which automatically fails at some time in the future with `error`.
 *  @param ms How many milliseconds until it succeeds.
 * @param error The error to place into the failed Task.
 */
export declare const failIn: <E>(ms: number, error: E) => Task<E, never>;
/**
 * Creates a Task will never finish.
 */
export declare const never: () => Task<never, never>;
/**
 * Execute task computation and call handlers on completion.
 * @param reject Function to call on failure.
 * @param resolve Function to call on success.
 * @param task The task to fork.
 */
export declare const fork: <E, S>(reject: Reject<E>, resolve: Resolve<S>, task: Task<E, S>) => {
    cancel: () => void;
};
/**
 * Chain a task to run after a previous task has succeeded.
 * @param fn Takes a successful result and returns a new task.
 * @param task The task which will chain to the next one on success.
 */
export declare const chain: <E, S, S2, E2>(fn: (result: S) => Task<E2, S2>, task: Task<E, S>) => Task<E | E2, S2>;
/**
 * When forked, run a function which can check whether the task has already succeeded.
 * @param fn The function which either returns a success value or undefined.
 * @param task The task to run if the check fails (returns undefined).
 */
export declare const succeedIf: <E, S>(fn: () => S | undefined, task: Task<E, S>) => Task<E, S>;
/**
 * A task which only runs once. Caches the success or failure. Be careful.
 * @alias share
 * @param task The task to cache results.
 */
export declare const onlyOnce: <E, S>(task: Task<E, S>) => Task<E, S>;
export declare const share: <E, S>(task: Task<E, S>) => Task<E, S>;
/**
 * Given a promise, create a Task which relies on it.
 * @param promise The promise we will gather the success from.
 */
export declare const fromPromise: <S>(maybePromise: S | Promise<S>) => Task<unknown, S>;
/**
 * Given an array of promises, create a Task which relies on it.
 * @param promise The promises we will gather the success from.
 */
export declare const fromPromises: <S>(promises: Promise<S>[]) => Task<unknown, S[]>;
/**
 * Take a function which generates a promise and lazily execute it.
 * @param getPromise The getter function
 */
export declare const fromLazyPromise: <S>(getPromise: () => S | Promise<S>) => Task<unknown, S>;
/**
 * Given a function that returns a promise, return a new function that
 * lazily returns a Task instead.
 * @param fn A function which returns a promise
 */
export declare const wrapPromiseCreator: <S, Args extends unknown[]>(fn: (...args: Args) => Promise<S>) => (...args: Args) => Task<unknown, S>;
/**
 * Given a task, create a Promise which resolves when the task does.
 * @param task The task we will convert to a promise.
 */
export declare const toPromise: <E, S>(task: Task<E, S>) => Promise<S>;
/**
 * Given an array of tasks, return the one which finishes first.
 * @alias select
 * @param tasks The tasks to run in parallel.
 */
export declare const race: <E, S>(tasks: Task<E, S>[]) => Task<E, S>;
export declare class LoopBreak<S> {
    readonly value: S;
    constructor(value: S);
}
export declare class LoopContinue<S> {
    readonly value: S;
    constructor(value: S);
}
/**
 * Given an initialValue, asynchronously loop until either a value is
 * resolved by returning a Task<E, LoopBreak<S>>.
 * @param fn A function that takes the current loop value and decides whether to continue or break.
 * @param initialValue The initial value.
 */
export declare const loop: <E, S, T>(fn: (currentValue: T) => Task<E, LoopBreak<S> | LoopContinue<T>>, initialValue: T) => Task<E, S>;
/**
 * An async reducer. Given an initial return value and an array of
 * items to sequentially loop over, pass each step through a reducer
 * function which returns a Task of the next reduced value.
 * @param fn
 * @param initialValue
 * @param items
 */
export declare const reduce: <E, T, V>(fn: (acc: V, currentValue: T, index: number, original: T[]) => Task<E, V>, initialValue: V, items: T[]) => Task<E, V>;
/**
 * Given an array of tasks, return the one which finishes successfully first.
 * @param tasks The tasks to run in parallel.
 */
export declare const firstSuccess: <E, S>(tasks: Task<E, S>[]) => Task<E[], S>;
/**
 * Given an array of task which return a result, return a new task which returns an array of results.
 * @alias collect
 * @param tasks The tasks to run in parallel.
 */
export declare const all: <E, S>(tasks: Task<E, S>[]) => Task<E, S[]>;
/**
 * Given an array of task which return a result, return a new task which returns an array of successful results.
 * @param tasks The tasks to run in parallel.
 */
export declare const allSuccesses: <E, S>(tasks: Task<E, S>[]) => Task<never, S[]>;
/**
 * Creates a task that waits for two tasks of different types to
 * resolve as a two-tuple of the results.
 * @param taskA The first task.
 * @param taskB The second task.
 */
export declare const zip: <E, E2, S, S2>(taskA: Task<E, S>, taskB: Task<E2, S2>) => Task<E | E2, [S, S2]>;
/**
 * Creates a task that waits for two tasks of different types to
 * resolve, then passing the resulting two-tuple of results through
 * a mapping function.
 * @param fn
 * @param taskA The first task.
 * @param taskB The second task.
 */
export declare const zipWith: <E, E2, S, S2, V>(fn: (resultA: S, resultB: S2) => V, taskA: Task<E, S>, taskB: Task<E2, S2>) => Task<E | E2, V>;
/**
 * Given an array of task which return a result, return a new task which results an array of results.
 * @param tasks The tasks to run in sequence.
 */
export declare const sequence: <E, S>(tasks: Task<E, S>[], maxConcurrent?: number) => Task<E, S[]>;
/**
 * Given a task, swap the error and success values.
 * @param task The task to swap the results of.
 */
export declare const swap: <E, S, E2 extends E, S2 extends S>(task: Task<E, S>) => Task<S2, E2>;
/**
 * Given a task, map the successful value to a Task.
 * @param fn A function which takes the original successful result and returns the new one.
 * @param task The task to map the succcessful result.
 */
export declare const map: <E, S, S2>(fn: (result: S) => S2, task: Task<E, S>) => Task<E, S2>;
export declare const map2: <E, E2, S, S2, S3>(fn: (a: S) => (b: S2) => S3, taskA: Task<E, S>, taskB: Task<E2, S2>) => Task<E | E2, S3>;
export declare const map3: <E, E2, E3, S, S2, S3, S4>(fn: (a: S) => (b: S2) => (c: S3) => S4, taskA: Task<E, S>, taskB: Task<E2, S2>, taskC: Task<E3, S3>) => Task<E | E2 | E3, S4>;
export declare const map4: <E, E2, E3, E4, S, S2, S3, S4, S5>(fn: (a: S) => (b: S2) => (c: S3) => (d: S4) => S5, taskA: Task<E, S>, taskB: Task<E2, S2>, taskC: Task<E3, S3>, taskD: Task<E4, S4>) => Task<E | E2 | E3 | E4, S5>;
/**
 * Run a side-effect on success. Useful for logging.
 * @param fn A function will fire with the successful value.
 * @param task The task to tap on succcess.
 */
export declare const tap: <E, S>(fn: (result: S) => void, task: Task<E, S>) => Task<E, S>;
/**
 * Run an additional task on success. Useful for async side-effects.
 * @alias defer
 * @param fn A function will fire with the successful value.
 * @param task The task to tap on succcess.
 */
export declare const tapChain: <E, S, S2>(fn: (result: S) => Task<E, S2>, task: Task<E, S>) => Task<E, S>;
/**
 * Run a function on a successful value which can fail the task or modify the type.
 * @param fn A function will return a Validation on the value.
 * @param task The task to tap on succcess.
 */
export declare const validate: <E, S, E2, S2>(fn: (value: S) => Validation<E2, S2>, task: Task<E, S>) => Task<E | E2, S2>;
/**
 * Given a task, map the failure error to a Task.
 * @alias recoverWith
 * @alias rescue
 * @param fn A function which takes the original failure error and returns the new one.
 * @param task The task to map the failure.
 */
export declare const mapError: <E, S, E2>(fn: (error: E) => E2, task: Task<E, S>) => Task<E2, S>;
export declare const validateError: <E, S, E2 extends E>(fn: (err: E) => err is E2, task: Task<E, S>) => Task<E2, S>;
export declare const errorUnion: <E, S, E2>(task: Task<E, S>) => Task<E | E2, S>;
/**
 * Given a task, map both the failure error and the success result to a Task.
 * @param handleError A function which takes the original failure error and returns the new one.
 * @param handleSuccess A function which takes the original successful result and returns the new one.
 * @param task The task to map the failure and succeess of.
 */
export declare const mapBoth: <E, S, E2, S2>(handleError: (error: E) => E2, handleSuccess: (success: S) => S2, task: Task<E, S>) => Task<E2, S2>;
/**
 * Given a task, map both the failure error and the success result to a Task which always succeeds.
 * @param handleError A function which takes the original failure error and returns a successful result.
 * @param handleSuccess A function which takes the original successful result and returns a new successful result.
 * @param task The task to map failure and succeess to a success for.
 */
export declare const fold: <E, S, R>(handleError: (error: E) => R, handleSuccess: (success: S) => R, task: Task<E, S>) => Task<never, R>;
/**
 * Given a task, if the result in a failure, attemp to generate another Task from the error.
 * @param fn A function which takes the original failure error and returns a Task.
 * @param task The task to try to run a recovery function on failure.
 */
export declare const orElse: <E, S>(fn: (error: E) => Task<E, S>, task: Task<E, S>) => Task<E, S>;
/**
 * Given a task that succeeds with a map function as its result,
 * run that function over the result of a second successful Task.
 * @param appliedTask The task whose value will be passed to the map function.
 * @param task The task who will return a map function as the success result.
 */
export declare const ap: <E, S, S2>(task: Task<E, (result: S) => S2>, appliedTask: Task<E, S>) => Task<E, S2>;
/**
 * Wait some number of seconds to continue after a successful task.
 * @param ms How long to wait in milliseconds.
 * @param task Which task to wait to succeed with.
 */
export declare const wait: <E, S>(ms: number, task: Task<E, S>) => Task<E, S>;
/**
 * If a task fails, retry it in the future.
 * @param ms How long to wait before trying.
 * @param task Which task to retry.
 */
export declare const retryIn: <E, S>(ms: number, task: Task<E, S>) => Task<E, S>;
/**
 * If a task fails, retry it X times, with exponential backoff.
 * @param ms How long to wait before trying the first time.
 * @param times How many times to attempt, each waiting 2x the previous time.
 * @param task Which task to retry.
 */
export declare const retryWithExponentialBackoff: <E, S>(ms: number, times: number, task: Task<E, S>) => Task<E, S>;
/**
 * Takes a nested task of tasks, which often comes from a map, and
 * flattens to just the resulting chained task.
 * @param task The task which resolves to an other task.
 */
export declare const flatten: <E, S>(task: Task<E, Task<E, S>>) => Task<E, S>;
/**
 * Given a predicate, if it returns true, error the task with a given value.
 * @param pred Run this on a successful task, return true to fail the task.
 * @param error If the predicate succeeded, run this function to get the error result.
 */
export declare const failIf: <E, S, E2>(pred: (result: S) => boolean, error: (result: S) => E2, task: Task<E, S>) => Task<E | E2, S>;
/**
 * Create a new task.
 * @param computation A function which will be run when the task starts.
 */
export declare class Task<E, S> implements PromiseLike<S> {
    private computation;
    static fail: <E_1>(error: E_1) => Task<E_1, never>;
    static succeed: <S_1>(result: S_1) => Task<never, S_1>;
    static empty: () => Task<never, undefined>;
    static failIn: <E_1>(ms: number, error: E_1) => Task<E_1, never>;
    static succeedIn: <S_1>(ms: number, result: S_1) => Task<never, S_1>;
    static of: <S_1>(result: S_1) => Task<never, S_1>;
    static all: <E_1, S_1>(tasks: Task<E_1, S_1>[]) => Task<E_1, S_1[]>;
    static allSuccesses: <E_1, S_1>(tasks: Task<E_1, S_1>[]) => Task<never, S_1[]>;
    static sequence: <E_1, S_1>(tasks: Task<E_1, S_1>[], maxConcurrent?: number) => Task<E_1, S_1[]>;
    static firstSuccess: <E_1, S_1>(tasks: Task<E_1, S_1>[]) => Task<E_1[], S_1>;
    static never: () => Task<never, never>;
    static fromPromise: <S_1>(maybePromise: S_1 | Promise<S_1>) => Task<unknown, S_1>;
    static fromPromises: <S_1>(promises: Promise<S_1>[]) => Task<unknown, S_1[]>;
    static fromLazyPromise: <S_1>(getPromise: () => S_1 | Promise<S_1>) => Task<unknown, S_1>;
    static wrapPromiseCreator: <S_1, Args extends unknown[]>(fn: (...args: Args) => Promise<S_1>) => (...args: Args) => Task<unknown, S_1>;
    static race: <E_1, S_1>(tasks: Task<E_1, S_1>[]) => Task<E_1, S_1>;
    static external: <E_1, S_1>() => ExternalTask<E_1, S_1>;
    static emitter: <Args extends unknown[], R>(fn: (...args: Args) => R) => [ExternalTask<unknown, R>, (...args: Args) => void];
    static succeedBy: <S_1>(result: () => S_1) => Task<unknown, S_1>;
    static ap: <E_1, S_1, S2>(task: Task<E_1, (result: S_1) => S2>, appliedTask: Task<E_1, S_1>) => Task<E_1, S2>;
    static map2: <E_1, E2, S_1, S2, S3>(fn: (a: S_1) => (b: S2) => S3, taskA: Task<E_1, S_1>, taskB: Task<E2, S2>) => Task<E_1 | E2, S3>;
    static map3: <E_1, E2, E3, S_1, S2, S3, S4>(fn: (a: S_1) => (b: S2) => (c: S3) => S4, taskA: Task<E_1, S_1>, taskB: Task<E2, S2>, taskC: Task<E3, S3>) => Task<E_1 | E2 | E3, S4>;
    static map4: <E_1, E2, E3, E4, S_1, S2, S3, S4, S5>(fn: (a: S_1) => (b: S2) => (c: S3) => (d: S4) => S5, taskA: Task<E_1, S_1>, taskB: Task<E2, S2>, taskC: Task<E3, S3>, taskD: Task<E4, S4>) => Task<E_1 | E2 | E3 | E4, S5>;
    static loop: <E_1, S_1, T>(fn: (currentValue: T) => Task<E_1, LoopBreak<S_1> | LoopContinue<T>>, initialValue: T) => Task<E_1, S_1>;
    static reduce: <E_1, T, V>(fn: (acc: V, currentValue: T, index: number, original: T[]) => Task<E_1, V>, initialValue: V, items: T[]) => Task<E_1, V>;
    static zip: <E_1, E2, S_1, S2>(taskA: Task<E_1, S_1>, taskB: Task<E2, S2>) => Task<E_1 | E2, [S_1, S2]>;
    static zipWith: <E_1, E2, S_1, S2, V>(fn: (resultA: S_1, resultB: S2) => V, taskA: Task<E_1, S_1>, taskB: Task<E2, S2>) => Task<E_1 | E2, V>;
    static flatten: <E_1, S_1>(task: Task<E_1, Task<E_1, S_1>>) => Task<E_1, S_1>;
    isCanceled: boolean;
    constructor(computation: Fork<E, S>);
    fork(reject: Reject<E>, resolve: Resolve<S>): {
        cancel: () => void;
    };
    cancel(): void;
    /**
     * Alias to match promise API and let async/await work.
     * Mostly "private". Do not use.
     */
    then<TResult1 = S, TResult2 = never>(onfulfilled?: ((value: S) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
    chain<E2, S2>(fn: (result: S) => Task<E2, S2>): Task<E | E2, S2>;
    succeedIf(fn: () => S | undefined): Task<E, S>;
    onlyOnce(): Task<E, S>;
    toPromise(): Promise<S>;
    swap<E2 extends E, S2 extends S>(): Task<S2, E2>;
    map<S2>(fn: (result: S) => S2): Task<E, S2>;
    forward<S2>(value: S2): Task<E, S2>;
    append<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): Task<E, [S, A, B, C, D, E]>;
    append<A, B, C, D>(a: A, b: B, c: C, d: D): Task<E, [S, A, B, C, D]>;
    append<A, B, C>(a: A, b: B, c: C): Task<E, [S, A, B, C]>;
    append<A, B>(a: A, b: B): Task<E, [S, A, B]>;
    append<A>(a: A): Task<E, [S, A]>;
    prepend<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E): Task<E, [S, A, B, C, D, E]>;
    prepend<A, B, C, D>(a: A, b: B, c: C, d: D): Task<E, [A, B, C, D, S]>;
    prepend<A, B, C>(a: A, b: B, c: C): Task<E, [A, B, C, S]>;
    prepend<A, B>(a: A, b: B): Task<E, [A, B, S]>;
    prepend<A>(a: A): Task<E, [A, S]>;
    tap(fn: (result: S) => void): Task<E, S>;
    tapChain<S2>(fn: (result: S) => Task<E, S2>): Task<E, S>;
    validate<E2, S2>(fn: (value: S) => Validation<E2, S2>): Task<E | E2, S2>;
    mapError<E2>(fn: (error: E) => E2): Task<E2, S>;
    validateError<E2 extends E>(fn: (err: E) => err is E2): Task<E2, S>;
    errorUnion<E2>(): Task<E | E2, S>;
    mapBoth<E2, S2>(handleError: (error: E) => E2, handleSuccess: (success: S) => S2): Task<E2, S2>;
    fold<R>(handleError: (error: E) => R, handleSuccess: (success: S) => R): Task<never, R>;
    orElse<S2>(fn: (error: E) => Task<E, S | S2>): Task<E, S | S2>;
    ap<E2, S2, S3 = S extends (arg: S2) => unknown ? ReturnType<S> : never>(task: Task<E | E2, S2>): Task<E | E2, S3>;
    wait(ms: number): Task<E, S>;
    retryIn(ms: number): Task<E, S>;
    retryWithExponentialBackoff(ms: number, times: number): Task<E, S>;
    flatten<S2>(this: Task<E, Task<E, S2>>): Task<E, S2>;
    failIf<E2>(pred: (result: S) => boolean, error: (result: S) => E2): Task<E | E2, S>;
}
/**
 * A special form of Task which can be resolved/rejected externally.
 */
export declare class ExternalTask<E, S> extends Task<E, S> {
    private computationReject_?;
    private computationResolve_?;
    private alreadyError_?;
    private alreadyResult_?;
    private lastState_;
    constructor();
    reject(error: E): void;
    resolve(result: S): void;
}
declare global {
    interface Promise<T> {
        toTask(): Task<unknown, T>;
    }
}
//# sourceMappingURL=Task.d.ts.map