/** A promise that resolves after `ms`. */
export declare function delay(ms: number): Promise<void>;
/**
 * Results in input order.
 *
 * A sliding window of `limit` in-flight promises: push until it is full, then
 * yield the oldest. Head-of-line blocking is the price — a slow record holds
 * back the ones behind it — and it buys output you can write straight to a file
 * next to the input.
 */
export declare function mapOrdered<In, Out>(source: AsyncIterable<In> | Iterable<In>, limit: number, work: (item: In, index: number) => Promise<Out>, signal?: AbortSignal): AsyncGenerator<Out>;
/**
 * Results in completion order.
 *
 * Each promise carries its own key so the settled one can be removed from the
 * pool — `Promise.race` tells you the value, never which promise produced it.
 */
export declare function mapUnordered<In, Out>(source: AsyncIterable<In> | Iterable<In>, limit: number, work: (item: In, index: number) => Promise<Out>, signal?: AbortSignal): AsyncGenerator<Out>;
/**
 * No promises at all.
 *
 * When nothing in the pipeline awaits — word lists and PII detection are both
 * synchronous — two promises per record is pure overhead, and at a million
 * records it is the difference you can measure.
 */
export declare function mapSync<In, Out>(source: AsyncIterable<In> | Iterable<In>, work: (item: In, index: number) => Out, signal?: AbortSignal): AsyncGenerator<Out>;
//# sourceMappingURL=concurrency.d.ts.map