import "./_dnt.polyfills.js";
import type { IterableItem } from "./iterable.js";
import { type PromiseMaybe } from "./promise-helper.js";
import type { PureEvent } from "./pure_event.js";
export * from "./promise-helper.js";
export type Timmer<T = unknown> = (resolve: (result: T) => void, reject: (reason?: unknown) => void) => Timmer.Clear;
export declare namespace Timmer {
    type Clear = () => void;
    type From<T extends number | Timmer<any>> = T extends number ? Timmer<void> : T;
    type Type<T> = T extends Timmer<infer R> ? Timmer<R> : never;
    type FromType<T extends number | Timmer<any>> = T extends number ? void : T extends Timmer<infer R> ? R : never;
}
export declare const timmers: {
    timeout: (ms: number) => Timmer<void>;
    raf: Timmer<number>;
    microtask: Timmer<void>;
    eventTarget: <T extends Event>(target: Pick<EventTarget, "addEventListener" | "removeEventListener">, eventType: string, filter?: (event: T) => boolean | void) => Timmer<T>;
    from: <T extends number | Timmer<any>>(ms: T) => Timmer.From<T>;
};
/**
 * setTimeout/clearTimeout 的 promise 版本
 * @example
 * ```ts
 * const d = delay(1000)
 *
 * await d; // is promise
 *
 * d.cancel(); // clearTimeout
 *
 * d.cancel('some reason'); // clearTimeout and reject promise
 *
 * const ac = new AbortController()
 * const d = delay(1000, { signal: ac.signal }) // with AbortSignal
 * ac.abort('some reason'); // clearTimeout and reject promise
 * ```
 *
 * 如果 ms = 0，那么会使用 queueMicrotask 而不是setTimeot，当然cancel仍然是可以工作的
 */
export declare const delay: <T extends number | Timmer<any>>(ms: T, options?: {
    signal?: AbortSignal | null;
    disposer?: PureEvent<void>;
}) => delay.Delayer<Timmer.FromType<T>>;
export declare namespace delay {
    type Delayer<T = void> = Promise<T> & {
        cancel(cause?: unknown): void;
    };
}
export declare const promise_try: <R>(fn: () => R) => Promise<PromiseSettledResult<Awaited<R>>>;
export type PromiseOnceThenTask<T> = {
    key?: unknown;
    resolve?: null | ((value: T) => void);
    reject?: null | ((error: any, value?: T) => void);
};
/**
 * 一个内存安全的、只专注于执行回调 promise then 方法。
 * 因为 promise.then 是会创建一个新的 promise 的，在某些场景下，这会带来严重的内存问题，比如说，如果你将一个 promise 作为一个锁
 * 而如果你只是想进行回调注册，使用这个方法。
 *
 * @param promise
 * @param onfulfilled
 * @param onrejected
 * @returns
 */
export declare const promise_once_then: <P extends PromiseLike<any>, T = Awaited<P>>(promise: P, task: PromiseOnceThenTask<T>) => (() => void);
export declare const promise_once_then_cancel: <P extends PromiseLike<any>, T = Awaited<P>>(promise: P, task: PromiseOnceThenTask<T>) => void;
export type PromiseRaceOptions<T> = {
    ifEmpty?: () => PromiseMaybe<T>;
};
export declare const promise_safe_race: <V extends Iterable<any>, T = Awaited<IterableItem<V, unknown>>>(values: V, options?: PromiseRaceOptions<T>) => PromiseMaybe<T>;
//# sourceMappingURL=promise.d.ts.map