//#region src/dispatch.d.ts
type Handler = () => void;
type Transition = (work: Handler) => void;
type Hold = (retry?: Handler | false) => void;
/**
 * Hold the work being replayed until the returned callback runs - a subscriber
 * which has not yet absorbed the update takes one, and settlement waits on it
 * rather than on the replay. Returns nothing unless the replay carries pending
 * work, so an unrelated subscriber pays for none of it.
 */
declare function hold(detached?: true, transition?: Transition): Hold | undefined;
/**
 * Queue `handler` to replay after this tick. `transition` is how this
 * subscriber defers - it brackets the replay, but only where the scheduled
 * work asked for one.
 */
declare function enqueue(handler: Handler, transition?: Transition): void;
/**
 * Run `work` now, marking the subscriber updates it queues non-urgent - each
 * replays through whatever scheduler it subscribed with. The callback itself is
 * synchronous; only what it notifies is pending.
 *
 * Resolves once every one of those updates has replayed and been absorbed. A
 * subscriber which cannot report absorption resolves on replay; one which can
 * defer brackets its own replay.
 */
declare function pending(work: Handler): Promise<void>;
/**
 * Declare the subscriber currently replaying has not absorbed its update yet -
 * settlement waits on the returned callback rather than on the replay. Call
 * only from inside a replay carrying pending work; elsewhere this returns
 * nothing and the subscriber pays for none of it.
 */
declare function pending(): (() => void) | undefined;
//#endregion
export { enqueue, hold, pending };
//# sourceMappingURL=dispatch.d.ts.map