/** Make Promise or AsyncIterable abortable with the given signal. */
export declare function abortable<T>(p: Promise<T>, signal: AbortSignal): Promise<T>;

export declare function abortable<T>(p: AsyncIterable<T>, signal: AbortSignal): AsyncGenerator<T>;

/** Make AsyncIterable abortable with the given signal. */
export declare function abortableAsyncIterable<T>(p: AsyncIterable<T>, signal: AbortSignal): AsyncGenerator<T>;

/** Make Promise abortable with the given signal. */
export declare function abortablePromise<T>(p: Promise<T>, signal: AbortSignal): Promise<T>;

/**
 * Create a promise which will be rejected with DeadlineError when a given delay is exceeded.
 */
export declare function deadline<T>(p: Promise<T>, delay: number): Promise<T>;

export declare class DeadlineError extends Error {
    constructor();
}

/**
 * Creates a debounced function that delays the given `func`
 * by a given `wait` time in milliseconds. If the method is called
 * again before the timeout expires, the previous call will be
 * aborted.
 *
 * ```
 * import { debounce } from "./debounce.ts";
 *
 * const log = debounce(
 *   (event: Deno.FsEvent) =>
 *     console.log("[%s] %s", event.kind, event.paths[0]),
 *   200,
 * );
 *
 * for await (const event of Deno.watchFs("./")) {
 *   log(event);
 * }
 * ```
 *
 * @param fn    The function to debounce.
 * @param wait  The time in milliseconds to delay the function.
 */
export declare function debounce<T extends Array<any>>(fn: (this: DebouncedFunction<T>, ...args: T) => void, wait: number): DebouncedFunction<T>;

/**
 * A debounced function that will be delayed by a given `wait`
 * time in milliseconds. If the method is called again before
 * the timeout expires, the previous call will be aborted.
 */
export declare interface DebouncedFunction<T extends Array<unknown>> {
    (...args: T): void;
    /** Clears the debounce timeout and omits calling the debounced function. */
    clear(): void;
    /** Clears the debounce timeout and calls the debounced function immediately. */
    flush(): void;
    /** Returns a boolean wether a debounce call is pending or not. */
    readonly pending: boolean;
}

export declare interface Deferred<T> extends Promise<T> {
    readonly state: "pending" | "fulfilled" | "rejected";
    resolve(value?: T | PromiseLike<T>): void;
    reject(reason?: any): void;
}

/** Creates a Promise with the `reject` and `resolve` functions
 * placed as methods on the promise object itself. It allows you to do:
 *
 * ```ts
 *     import { deferred } from "./deferred.ts";
 *
 *     const p = deferred<number>();
 *     // ...
 *     p.resolve(42);
 * ```
 */
export declare function deferred<T>(): Deferred<T>;

export declare function delay(ms: number, options?: DelayOptions_2): Promise<void>;

declare interface DelayOptions_2 {
    signal?: AbortSignal;
}
export { DelayOptions_2 as DelayOptions }

/** The MuxAsyncIterator class multiplexes multiple async iterators into a
 * single stream. It currently makes an assumption:
 * - The final result (the value returned and not yielded from the iterator)
 *   does not matter; if there is any, it is discarded.
 */
export declare class MuxAsyncIterator<T> implements AsyncIterable<T> {
    private iteratorCount;
    private yields;
    private throws;
    private signal;
    add(iterable: AsyncIterable<T>): void;
    private callIteratorNext;
    iterate(): AsyncIterableIterator<T>;
    [Symbol.asyncIterator](): AsyncIterator<T>;
}

/**
 * pooledMap transforms values from an (async) iterable into another async
 * iterable. The transforms are done concurrently, with a max concurrency
 * defined by the poolLimit.
 *
 * If an error is thrown from `iterableFn`, no new transformations will begin.
 * All currently executing transformations are allowed to finish and still
 * yielded on success. After that, the rejections among them are gathered and
 * thrown by the iterator in an `AggregateError`.
 *
 * @param poolLimit The maximum count of items being processed concurrently.
 * @param array The input array for mapping.
 * @param iteratorFn The function to call for every item of the array.
 */
export declare function pooledMap<T, R>(poolLimit: number, array: Iterable<T> | AsyncIterable<T>, iteratorFn: (data: T) => Promise<R>): AsyncIterableIterator<R>;

/**
 * Branches the given async iterable into the n branches.
 *
 * Example:
 *
 * ```ts
 *     import { tee } from "./tee.ts";
 *
 *     const gen = async function* gen() {
 *       yield 1;
 *       yield 2;
 *       yield 3;
 *     }
 *
 *     const [branch1, branch2] = tee(gen());
 *
 *     (async () => {
 *       for await (const n of branch1) {
 *         console.log(n); // => 1, 2, 3
 *       }
 *     })();
 *
 *     (async () => {
 *       for await (const n of branch2) {
 *         console.log(n); // => 1, 2, 3
 *       }
 *     })();
 * ```
 */
export declare function tee<T, N extends number = 2>(iterable: AsyncIterable<T>, n?: N): Tuple<AsyncIterable<T>, N>;

declare type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : TupleOf<T, N, []> : never;

declare type TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : TupleOf<T, N, [T, ...R]>;

export { }