/**
 *  生成一个异步控制信号
 *
 *  当满足condition时会进行等待
 *
 *  定义一个异步等待信号
 *  let signal = asyncSignal()
 *
 *  //
 *  然后在需要等待的地方
 *  await signal()
 *  await signal(100)  代表信号会自动超时resolve
 *  await signal(100,new Error())  代表信号会自动超时reject
 *
 *  可以手动resolve或reject该signal
 *  当要结束等待时调用 signal.resolve()
 *  当等待出错时调用 signal.reject()
 *
 * 可以传入一个condition函数，当signal.resolve时，会同时进行调用，该函数必须返回true，否则会继承等待
 * 超时时不会调用
 * let signal = asyncSignal(()=>{})
 *
 *  当signal使用一次后，如果需要再次使用，则需要signal.reset()复位一下，然后就可以
 *   await signal()
 *
 *  @param {Function} constraint 约束函数，指定当resolve或reject时，需要同时满足这个约束函数返回true才会进行resolve或reject
 *
 */
declare class AsyncSignalAbort extends Error {
}
interface IAsyncSignal {
    (timeout?: number, returns?: any): Awaited<Promise<any>>;
    id: number;
    reset(): void;
    reject(e?: Error | string): void;
    resolve(result?: any): void;
    destroy(): void;
    isResolved(): boolean;
    isRejected(): boolean;
    isPending(): boolean;
}
/**
 * 生成一个异步信号
 *
 * const signal = asyncSignal()
 * const signal = asyncSignal(()=>x==1,{timeout:10})
 *
 * await  signal(timeout)
 * signal.resolve()
 * signal.reject()
 * signal.destroy()
 *
 * @param {function} constraint
 *      当调用signal.resolve()时，还需要满足额外的约束条件，仅当constraint返回true，则signal才可以进行真正resolve
 * @returns {function}
 */
declare function asyncSignal(constraint?: Function, options?: {
    timeout: number;
}): IAsyncSignal;
/**
 *   管理多个异步信号，并确保能正确resolve和reject
 *
 *
 *
 *  let signals = new AsyncSignalManager({
 *      timeout:60 * 1000,               // 所有信号均在1分钟后自动超时，0代表不设超时，并且此值应该大于signal(timeout)时指定的超时值
 *  })
 *
 *  signal = signals.create() 创建一个asyncSignal
 *
 *  signals.destroy()   销毁所有异步信号
 *  signal.resolve()    resolve所有异步信号
 *  signal.reject()     reject所有异步信号
 *  signal.reset()      reset所有异步信号
 *
 *
 */
declare class AsyncSignalManager {
    #private;
    options?: {
        timeout: number;
    } | undefined;
    constructor(options?: {
        timeout: number;
    } | undefined);
    get signals(): Record<string, IAsyncSignal>;
    /**
     * 创建新的异步信号
     * @param constraint         额外的约束条件
     * @param id
     */
    create(constraint?: Function): IAsyncSignal;
    /**
     * 销毁指定的或者所有异步信号
     *
     *  destroy(id)
     *  destroy([id,id,...])
     *  destroy()                   // 销毁所有
     * @param {string} id           可选的信号id,如果未指定则删除所有的信号
     *
     */
    destroy(id: number | number[] | undefined): void;
    resolve(): void;
    reject(e: Error | string): void;
    reset(): void;
}

export { AsyncSignalAbort, AsyncSignalManager, type IAsyncSignal, asyncSignal };