import { AsyncLocalStorage } from "async_hooks";
import { ParentPool } from "./ParentPool";
export declare const asyncLocalStorage: AsyncLocalStorage<unknown>;
interface PromiseInfo {
    reject: (reason: any) => void;
    syncExit: boolean;
    result: "rejected" | "resolved" | undefined;
}
export declare class ProcessAwarePromiseFactory {
    private processExitError;
    setProcessExit(e: Error): void;
    clearProcessExit(): void;
    idx: number;
    parentPool: ParentPool<PromiseInfo, string>;
    transferTimers: Set<NodeJS.Timeout>;
    origSetTimeout: typeof setTimeout;
    from: "await-then" | "then" | "catch" | "yield-then" | "finally" | undefined;
    constructor(origSetTimeout: typeof setTimeout);
    makePromiseClass(): {
        new <T>(executor: (res: (r: T | PromiseLike<T>) => void, rej: (e: any) => void) => void): {
            transferTimer: NodeJS.Timeout;
            /**
             * The id of this promise as a parent in the parent pool
             */
            selfParentId: string;
            catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
            then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
            finally(onfinally?: (() => void) | null | undefined): Promise<T>;
            releaseParentClaims(): void;
            readonly [Symbol.toStringTag]: string;
        };
        all<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
        all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
        race<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
        race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
        reject<T = never>(reason?: any): Promise<T>;
        resolve(): Promise<void>;
        resolve<T>(value: T): Promise<Awaited<T>>;
        resolve<T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
        allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;
        allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]>;
        readonly [Symbol.species]: PromiseConstructor;
    };
    private getProcessExitError;
    /**
     * Used to make sure we don't overlap state
     */
    clear(): void;
    private handleThenableCatch;
}
export {};