//#region src/common/exec/promise.d.ts
/**
 * Promise to be used with `await`. Example:
 *
 * ```
 * const [promise, resolve, reject] = createPromise()
 * setTimeout(() => {
 *   resolve(5)
 * }, 50)
 * const result = await promise
 * ```
 */
declare function createPromise<T>(): [Promise<T>, any, any];
/** Sleep for `milliSeconds`. Example 1s: `await sleep(1000)` */
declare function sleep(milliSeconds: number): Promise<void>;
/** Same as `await sleep(0)`, just let the event loop execute. */
declare function immediate(): Promise<void>;
declare function timeout<T>(promise: Promise<T>, milliSeconds: number, timeoutValue?: string): Promise<T | typeof timeoutValue>;
declare function isTimeout(value: any): boolean;
declare function tryTimeout<T>(promise: Promise<T>, milliSeconds: number): Promise<T | undefined>;
/**
 * @deprecated use emitter.waitOn
 * Wait for `event` on `obj` to emit. Resolve with result or reject on `timeout`
 */
declare function waitOn(obj: any, event: string, timeoutMS?: number): Promise<any>;
declare function isPromise<T>(value: Promise<T> | T): value is Promise<T>;
/** This is exactly what Prose.resolve(x) is supposed to be: return a Promise no matter what type x is */
declare function promisify<T>(value: Promise<T> | T): Promise<T>;
/**
 *  Like ReturnType but for async functions.
 *  From https://www.jpwilliams.dev/how-to-unpack-the-return-type-of-a-promise-in-typescript
 */
type AsyncReturnType<T extends (...args: any) => any> = T extends ((...args: any) => Promise<infer U>) ? U : T extends ((...args: any) => infer U) ? U : any;
//#endregion
export { isTimeout as a, timeout as c, isPromise as i, tryTimeout as l, createPromise as n, promisify as o, immediate as r, sleep as s, AsyncReturnType as t, waitOn as u };
//# sourceMappingURL=promise-CU_CENbU.d.cts.map