/** Cancellation Token */
export interface CancelToken {
    /** Has it been cancelled or whether cancellation has been requested */
    readonly cancelled: boolean;
    /** Communicates a request for cancellation */
    cancel(): void;
    /** If cancelled, throw `CancelGuard` */
    guard(): void;
    /** Register an event that will be triggered when cancelled */
    reg(f: () => void): void;
    /** Waiting for cancellation */
    reg(): Promise<void>;
    /** Unregister event */
    unReg(f: () => void): void;
}
/** Cancel Guard */
export declare class CancelGuard {
    #private;
    private constructor();
    is(source: CancelToken): boolean;
    static new(source: CancelToken): CancelGuard;
}
/** Sync cancelable */
export declare function syncCancelable<R>(f: (ctx: CancelToken) => R): R | void;
/** Async cancelable */
export declare function cancelable<R>(f: (ctx: CancelToken) => Promise<R>): Promise<R | void>;
/** Task Like */
export interface TaskLike<T> extends CancelToken, PromiseLike<T | void> {
    /** Run task */
    run(): PromiseLike<T | void>;
    /** Is running */
    running: boolean;
    /** Whether finished */
    finished: boolean;
}
/** Cancelable async task */
export declare class Task<T> implements TaskLike<T>, Promise<T | void> {
    #private;
    /** Creates a new Task */
    constructor(f: (self: Task<T>) => PromiseLike<T>);
    /** Creates a new Task with CancelToken */
    constructor(token: CancelToken, f: (self: Task<T>) => PromiseLike<T>);
    /** Communicates a request for cancellation */
    cancel(): void;
    /** If cancelled, throw CancelGuard */
    guard(): void;
    /** If cancelled will not continue */
    aguard(): Promise<void>;
    /** Register an event that will be triggered when cancelled */
    reg(f: () => any): void;
    /** Waiting for cancellation */
    reg(): Promise<void>;
    /** Unregister event */
    unReg(f: () => any): void;
    /** Has it been cancelled or whether cancellation has been requested */
    get cancelled(): boolean;
    /** Whether finished */
    get finished(): boolean;
    /** Is running */
    get running(): boolean;
    /** Run task
     *
     * Even if this function is not called the task will still run
    */
    run(): Promise<T | void>;
    /** Attaches callbacks for the resolution and/or rejection of the Promise. */
    then<TResult1 = T | void, TResult2 = never>(onfulfilled?: ((value: T | void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
    /** Attaches a callback for only the rejection of the Promise. */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult | void>;
    [Symbol.toStringTag]: string;
    /** Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The resolved value cannot be modified from the callback. */
    finally(onfinally?: (() => void) | null): Promise<T | void>;
    /** Run Task */
    static run<T>(f: (self: Task<T>) => PromiseLike<T>): Task<T>;
    /** Run Task with CancelToken */
    static run<T>(token: CancelToken, f: (self: Task<T>) => PromiseLike<T>): Task<T>;
    /** Run task with promise parameters
     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
     * a resolve callback used to resolve the promise with a value or the result of another promise,
     * and a reject callback used to reject the promise with a provided reason or error.
    */
    static exec<T>(executor: (self: Task<T>, resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Task<T>;
    /** Run task with promise parameters with CancelToken
     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
     * a resolve callback used to resolve the promise with a value or the result of another promise,
     * and a reject callback used to reject the promise with a provided reason or error.
    */
    static exec<T>(token: CancelToken, executor: (self: Task<T>, resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Task<T>;
    /** Cancelable async delay */
    static delay(ms?: number): Task<void>;
    /** Cancelable async delay with CancelToken */
    static delay(token: CancelToken, ms?: number): Task<void>;
    /** Yield time slice and not continue if cancelled */
    static yield(token?: CancelToken): Task<void>;
    /** Yield time slice and not continue if cancelled, using this as CancelToken */
    yield(): Task<void>;
    /** Cancelable async delay, using this as CancelToken */
    delay(ms?: number): Task<void>;
    /** Run Task, using this as CancelToken */
    subRun<T>(f: (self: Task<T>) => PromiseLike<T>): Task<T>;
    /** Run task with promise parameters, using this as CancelToken
     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
     * a resolve callback used to resolve the promise with a value or the result of another promise,
     * and a reject callback used to reject the promise with a provided reason or error.
    */
    exec<T>(executor: (self: Task<T>, resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Task<T>;
    /** Creates a new cancelled task
     * @returns A cancelled task */
    static abort(): Task<never>;
    /**
     * Creates a new resolved task.
     * @returns A resolved task.
     */
    static resolve(): Task<void>;
    /**
     * Creates a new resolved task for the provided value.
     * @param value A task.
     * @returns A task whose internal state matches the provided task.
     */
    static resolve<T>(value: T | PromiseLike<T>): Task<T>;
    /**
     * Creates a new rejected promise for the provided reason.
     * @param reason The reason the promise was rejected.
     * @returns A new rejected Promise.
     */
    static reject<T = never>(reason?: any): Task<T>;
    /** Wait or cancel all task */
    static all<T extends any[]>(token: CancelToken, ...args: T): Task<{
        [K in keyof T]: T[K] extends PromiseLike<infer V> ? V : T[K];
    }>;
    /** Wait or cancel all task */
    all<T extends any[]>(...args: T): Task<{
        [K in keyof T]: T[K] extends PromiseLike<infer V> ? V : T[K];
    }>;
    /** Wait one and cancel other task */
    static race<T>(token: CancelToken, ...args: T[]): Task<T extends PromiseLike<infer U> ? U : T>;
    /** Wait one and cancel other task */
    race<T>(...args: T[]): Task<T extends PromiseLike<infer U> ? U : T>;
    static scope<T extends TaskLike<any>>(token: CancelToken, promise: T): Promise<T extends PromiseLike<infer R> ? R : T>;
    static scope<T extends PromiseLike<any>>(token: CancelToken, promise: T): Promise<T extends PromiseLike<infer R> ? R : T>;
    static scope<T>(token: CancelToken, promise: T): Promise<T extends PromiseLike<infer R> ? R : T>;
    scope<T extends TaskLike<any>>(promise: T): Promise<T extends PromiseLike<infer R> ? R : T>;
    scope<T extends PromiseLike<any>>(promise: T): Promise<T extends PromiseLike<infer R> ? R : T>;
    scope<T>(promise: T): Promise<T extends PromiseLike<infer R> ? R : T>;
}