modern-ts 0.8.0

package/dist/types/Concurrent/channel.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Special symbol indicating the channel is closed
+ * @remarks Returned by receive methods when channel is closed and no data remains
+ */
+export declare const CHANNEL_CLOSED: unique symbol;
+interface ResizeOptions {
+    /** Strategy when reducing capacity below current data size */
+    strategy?: 'error' | 'discard-oldest' | 'discard-newest';
+    /** Whether to process pending senders after resize */
+    flush_pending?: boolean;
+}
+declare const Tag_Channel: unique symbol;
+/**
+ * A channel implementing producer-consumer pattern with bounded capacity
+ * @template T Type of data transmitted through the channel
+ * @remarks
+ * - Uses a circular buffer for data storage
+ * - Maintains separate queues for waiting senders and receivers
+ * - Supports abort signals for async operations
+ * - Auto-compacts internal queues when many slots become empty
+ * @throws {UseAfterFreeError} When attempting operations after disposal
+ * @throws {ParameterError} When resize would lose data without explicit strategy
+ */
+export declare class Channel<T = unknown> {
+    readonly [Tag_Channel]: void;
+    private static readonly COMPACTION_THRESHOLD;
+    private static readonly MIN_QUEUE_SIZE_FOR_COMPACTION;
+    private buffer;
+    private buffer_head;
+    private buffer_tail;
+    private buffer_size;
+    private _capacity;
+    private state;
+    private senders;
+    private sender_head;
+    private receivers;
+    private receiver_head;
+    /**
+     * Creates a new channel with specified capacity
+     * @param capacity Maximum number of items buffer can hold (default: 0)
+     * @remarks Zero capacity creates a rendezvous channel (no buffering)
+     * @throws {RangeError} If capacity is negative (implicitly, through Math.max)
+     */
+    constructor(capacity?: number);
+    private throwIfDisposed;
+    private throwIfClosedOrDisposed;
+    private cleanupSender;
+    private cleanupReceiver;
+    private handleSenderAbort;
+    private handleReceiverAbort;
+    private processReceiver;
+    private processSender;
+    /**
+     * Changes the channel's capacity
+     * @param new_capacity New maximum buffer size
+     * @param options Resize behavior options
+     * @returns True if resize succeeded
+     * @throws {UseAfterFreeError} When channel is disposed or closed
+     * @throws {ParameterError} When new capacity < current data size and strategy='error'
+     * @remarks
+     * - Strategy 'discard-oldest' removes from buffer head
+     * - Strategy 'discard-newest' removes from buffer tail
+     * - By default, processes pending senders after successful resize
+     * - Buffer data is preserved and compacted during resize
+     */
+    resize(new_capacity: number, options?: ResizeOptions): boolean;
+    /**
+     * Attempts to resize channel, returns false on failure
+     * @param new_capacity New maximum buffer size
+     * @param options Resize behavior options
+     * @returns True if resize succeeded, false otherwise
+     * @remarks Does not throw on resize failure, returns false instead
+     */
+    tryResize(new_capacity: number, options?: ResizeOptions): boolean;
+    /**
+     * Asynchronously sends a value through the channel
+     * @param value Value to send
+     * @param signal Optional abort signal to cancel the send
+     * @returns Promise that resolves when value is accepted
+     * @throws {UseAfterFreeError} When channel is disposed or closed
+     * @throws {DOMException} When abort signal is already triggered
+     * @remarks
+     * 1. First tries to match with waiting receiver (rendezvous)
+     * 2. If buffer space available, stores immediately
+     * 3. Otherwise waits in sender queue until space available or abort
+     */
+    send(value: T, signal?: AbortSignal): Promise<void>;
+    /**
+     * Synchronously attempts to send a value
+     * @param value Value to send
+     * @returns True if value was accepted, false otherwise
+     * @throws {UseAfterFreeError} When channel is disposed or closed
+     * @remarks Does not wait - returns false immediately if no buffer space and no waiting receiver
+     */
+    sendSync(value: T): boolean;
+    /**
+     * Attempts to send a value if channel is open
+     * @param value Value to send
+     * @returns True if value was accepted, false if channel is closed
+     * @remarks Silent version of sendSync that returns false instead of throwing when closed
+     */
+    trySend(value: T): boolean;
+    /**
+     * Asynchronously receives a value from the channel
+     * @param signal Optional abort signal to cancel the receive
+     * @returns Promise resolving to received value or CHANNEL_CLOSED symbol
+     * @throws {UseAfterFreeError} When channel is disposed
+     * @throws {DOMException} When abort signal is already triggered
+     * @remarks
+     * 1. First tries to dequeue from buffer
+     * 2. If closed and buffer empty, returns CHANNEL_CLOSED
+     * 3. Otherwise waits in receiver queue until data available, channel closes, or abort
+     */
+    receive(signal?: AbortSignal): Promise<T | typeof CHANNEL_CLOSED>;
+    /**
+     * Synchronously attempts to receive a value
+     * @returns Received value, CHANNEL_CLOSED, or undefined if no data
+     * @throws {UseAfterFreeError} When channel is disposed
+     * @remarks
+     * - Returns T if data available in buffer or from waiting sender
+     * - Returns CHANNEL_CLOSED if channel closed and buffer empty
+     * - Returns undefined if no data available and channel still open
+     */
+    tryReceive(): T | typeof CHANNEL_CLOSED | undefined;
+    /**
+     * Clears all buffered data
+     * @returns Number of items drained from buffer
+     * @throws {UseAfterFreeError} When channel is disposed or closed
+     * @remarks Processes pending senders after draining if capacity > 0
+     */
+    drain(): number;
+    /**
+     * Closes the channel to new sends
+     * @remarks
+     * - Rejects all pending senders with UseAfterFreeError
+     * - Resolves all pending receivers with done: true
+     * - Does nothing if already closed or disposed
+     */
+    close(): void;
+    /**
+     * Disposes the channel, releasing all resources
+     * @remarks Calls close() then marks as disposed and clears buffer
+     */
+    dispose(): void;
+    /** 从环形缓冲区出队一个值，并处理可能等待的发送者 */
+    private dequeueBuffer;
+    /** 处理等待的发送者，利用缓冲区空间 */
+    private processPendingSenders;
+    /** 压缩接收队列以回收内存 */
+    private compactReceiverQueueIfNeeded;
+    /** 压缩队列，移除空槽并更新节点索引 */
+    private compactQueue;
+    /** Gets current channel statistics */
+    get stats(): {
+        capacity: number;
+        buffered: number;
+        waiting_senders: number;
+        waiting_receivers: number;
+        closed: boolean;
+        disposed: boolean;
+    };
+    /** Current channel capacity */
+    get capacity(): number;
+    /** Whether channel is closed to new sends */
+    get isClosed(): boolean;
+    /** Whether channel is fully disposed */
+    get isDisposed(): boolean;
+    /** Number of items currently buffered */
+    get buffered(): number;
+    /**
+     * Async iterator yielding values until channel closes
+     * @yields {T} Next value from channel
+     * @returns When channel closes
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<T, void, unknown>;
+    /**
+     * Receives values in batches
+     * @param max_size Maximum batch size (default: Infinity)
+     * @param signal Optional abort signal
+     * @yields {T[]} Batch of values
+     * @throws {DOMException} When abort signal triggered
+     * @remarks Yields final partial batch even if channel closes early
+     */
+    receiveBatch(max_size?: number, signal?: AbortSignal): AsyncGenerator<T[], void, unknown>;
+    /** Synchronous disposal (for using with `using` statement) */
+    [Symbol.dispose](): void;
+}
+type SelectableChannel<T> = {
+    trySend(value: T): boolean;
+    tryReceive(): T | typeof CHANNEL_CLOSED | undefined;
+    send(value: T, signal?: AbortSignal): Promise<void>;
+    receive(signal?: AbortSignal): Promise<T | typeof CHANNEL_CLOSED>;
+    readonly [Tag_Channel]: void;
+};
+interface SelectSendCase<T = unknown> {
+    op: 'send';
+    channel: SelectableChannel<T>;
+    value: T;
+}
+interface SelectReceiveCase<T = unknown> {
+    op: 'receive';
+    channel: SelectableChannel<T>;
+}
+type SelectCase<T = unknown> = SelectSendCase<T> | SelectReceiveCase<T>;
+export type SelectResult<C extends SelectCase<unknown>> = (C extends SelectSendCase<infer T> ? SelectSendCase<T> & {
+    value: T;
+} : C extends SelectReceiveCase<infer T> ? SelectReceiveCase<T> & {
+    value: T | typeof CHANNEL_CLOSED;
+} : never) | SelectDefaultResult;
+export interface SelectDefaultResult {
+    op: 'default';
+}
+export interface SelectOptions {
+    /**
+     * If provided, this function is called if no other case is ready immediately.
+     * This makes the select operation non-blocking.
+     */
+    default?: () => void;
+}
+/**
+ * Waits for multiple channel operations and returns when one completes.
+ * This implements CSP-style select semantics: it checks if any operation can
+ * proceed immediately without blocking; otherwise, it waits until one does.
+ *
+ * @template Cases The array type of select cases
+ * @param cases Array of send or receive cases
+ * @param signal Optional AbortSignal to cancel the entire select operation
+ * @param options Optional configuration object, supports 'default' callback for non-blocking behavior
+ * @returns Promise resolving to the case that fired, augmented with the value (for receive), or default
+ * @throws {UseAfterFreeError} If a channel operation fails permanently
+ * @throws {DOMException} If the provided signal is aborted
+ * @remarks
+ * - Prioritizes cases that can complete synchronously (using `trySend`/`tryReceive`).
+ * - If multiple are ready, the first one in the array is selected.
+ * - If none are ready and `options.default` is provided, it executes the callback and returns immediately.
+ * - If none are ready and no default is provided, it races async operations.
+ */
+export declare function select<Cases extends [SelectCase, ...SelectCase[]]>(cases: Cases, signal?: AbortSignal, options?: SelectOptions): Promise<SelectResult<Cases[number]>>;
+export {};

package/dist/types/Concurrent/delay.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Delays the execution for a specified number of milliseconds.
+ * @param ms - The duration to wait in milliseconds.
+ * @param signal - An optional `AbortSignal` to cancel the delay.
+ * If the signal is aborted, the promise rejects with a `DOMException`.
+ * @returns A promise that resolves after the timeout or rejects if aborted.
+ * @example
+ * ```ts
+ * try {
+ * await delay(1000, controller.signal);
+ * } catch (err) {
+ * console.error("Delayed action was cancelled!");
+ * }
+ * ```
+ */
+export declare function delay(ms: number, signal?: AbortSignal): Promise<void>;
+/**
+ * A safe version of the delay function that never rejects.
+ * Instead of rejecting on abort, it resolves with a DOMException.
+ * @param ms - The duration to wait in milliseconds.
+ * @param signal - An optional `AbortSignal` to cancel the delay.
+ * If the signal is aborted, the promise resolves with a `DOMException` instead of rejecting.
+ * @returns A promise that resolves after the timeout or resolves with a DOMException if aborted.
+ * This is useful when you want to handle abort conditions without try-catch blocks.
+ * @example
+ * ```ts
+ * const result = await delaySafe(1000, controller.signal);
+ * if (result instanceof DOMException) {
+ *   console.log("Delay was aborted:", result.message);
+ * } else {
+ *   console.log("Delay completed successfully");
+ * }
+ * ```
+ */
+export declare function delaySafe(ms: number, signal?: AbortSignal): Promise<undefined | DOMException>;
+/**
+ * A simplified, non-cancelable version of {@link delay}.
+ * Useful for basic pauses where abort logic is not required.
+ * @param ms - The duration to sleep in milliseconds.
+ * @returns A promise that resolves after the timeout.
+ */
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/types/Concurrent/ext/map.d.ts

@@ -0,0 +1,82 @@
+import { MaybePromise } from '../../Utils/type-tool';
+/** Symbol used to skip an item in the map result. */
+export declare const MAP_SKIP: unique symbol;
+export type MapSkipType = typeof MAP_SKIP;
+/** Options for {@link asyncMap}. */
+interface MapOptions {
+    /** Maximum number of concurrent map operations. Defaults to `Infinity`. */
+    readonly concurrency?: number;
+    /** If `true`, stop processing on first error and reject with that error. If `false`, collect errors and reject with `AggregateError` at the end. Defaults to `true`. */
+    readonly stopOnError?: boolean;
+    /** AbortSignal to cancel the operation. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Mapping function type used by {@link asyncMap} and {@link asyncMapIterable}.
+ *
+ * @template T - Type of the input item.
+ * @template R - Type of the mapped result.
+ * @param item - The current item from the iterable.
+ * @param index - The index of the current item.
+ * @returns The mapped value, a promise of it, or {@link MAP_SKIP} to exclude this item.
+ */
+type Mapper<T, R> = (item: T, index: number) => R | MapSkipType | PromiseLike<R | MapSkipType>;
+/**
+ * Asynchronously maps items from an iterable (sync/async) using a concurrency‑controlled mapper.
+ *
+ * The function processes items in parallel up to `concurrency`, and returns an array of results
+ * in the same order as the original iterable. Items for which the mapper returns `MAP_SKIP` are
+ * omitted from the final array.
+ *
+ * @template T - Type of items in the input iterable (may be wrapped in a promise).
+ * @template R - Type of the mapped results.
+ * @param iterable - Source of items. Can be synchronous, asynchronous, or contain promises.
+ * @param mapper - Async mapping function applied to each item.
+ * @param options - Configuration options.
+ * @returns Promise resolving to an array of mapped results (excluding skipped items).
+ *
+ * @example
+ * ```typescript
+ * const result = await asyncMap([1, 2, 3], async x => x * 2, { concurrency: 2 });
+ * // result = [2, 4, 6]
+ * ```
+ */
+export declare function asyncMap<T, R>(iterable: Iterable<MaybePromise<T>> | AsyncIterable<MaybePromise<T>>, mapper: Mapper<T, R>, { concurrency, stopOnError, signal }?: MapOptions): Promise<Array<R>>;
+/** Options for {@link asyncMapIterable}. */
+interface MapIterableOptions {
+    /** Maximum number of concurrent map operations. Defaults to `Infinity`. */
+    readonly concurrency?: number;
+    /**
+     * Maximum number of pending results buffered ahead of consumption.
+     * Must be at least `concurrency`. Helps to prevent the producer from outrunning the consumer.
+     * Defaults to `concurrency`.
+     */
+    readonly backpressure?: number;
+    /** AbortSignal to cancel the operation. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Asynchronously maps items from an iterable (sync/async) into an async generator,
+ * with concurrency control and backpressure.
+ *
+ * Items are processed in parallel up to `concurrency`, and results are yielded as soon as they
+ * become available (preserving the original order). Use `backpressure` to limit how many results
+ * are buffered ahead of consumption, preventing uncontrolled memory growth.
+ *
+ * @template T - Type of items in the input iterable (may be wrapped in a promise).
+ * @template R - Type of the mapped results.
+ * @param iterable - Source of items. Can be synchronous, asynchronous, or contain promises.
+ * @param mapper - Async mapping function applied to each item.
+ * @param options - Configuration options.
+ * @returns AsyncGenerator yielding mapped results (excluding skipped items).
+ *
+ * @example
+ * ```typescript
+ * const gen = asyncMapIterable([1, 2, 3], async x => x * 2, { concurrency: 2 });
+ * for await (const val of gen) {
+ *   console.log(val); // 2, 4, 6 (in order)
+ * }
+ * ```
+ */
+export declare function asyncMapIterable<T, R>(iterable: Iterable<MaybePromise<T>> | AsyncIterable<MaybePromise<T>>, mapper: Mapper<T, R>, { concurrency, backpressure, signal, }?: MapIterableOptions): AsyncGenerator<R, void, void>;
+export {};

package/dist/types/Concurrent/ext/other.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Options for timeout operations.
+ * @template T - The type of the original promise result
+ * @template R - The type of the fallback result (defaults to T)
+ */
+export interface TimeoutOptions<T, R = T> {
+    /** Timeout duration in milliseconds */
+    readonly ms: number;
+    /** Optional fallback function to call on timeout */
+    readonly fallback?: () => R;
+    /** Optional abort signal for cancellation */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Wraps a promise with a timeout, returning either the promise result or a fallback value.
+ *
+ * @template T - The type of the original promise result
+ * @template R - The type of the fallback result (defaults to never if no fallback)
+ * @param promise - The promise to wrap with timeout
+ * @param options - Timeout options including duration, fallback, and abort signal
+ * @returns A promise that resolves with the original result or fallback value, with a `clear` method to cancel
+ * @throws {ParameterError} If `ms` is not a positive integer
+ * @throws {DOMException} With 'TimeoutError' if timeout occurs without fallback, or 'AbortError' if cleared/cancelled
+ */
+export declare function asyncTimeout<T, R = never>(promise: PromiseLike<T>, options: TimeoutOptions<R>): Promise<T | R> & {
+    clear: () => void;
+};
+/**
+ * Executes an async mapper function over an array with controlled concurrency,
+ * returning settled results (fulfilled or rejected) for each element.
+ *
+ * @template T - The type of array elements
+ * @template R - The type of mapper result
+ * @param array - The array to process
+ * @param options - Options including concurrency limit, mapper function, and abort signal
+ * @returns An array of settled results preserving the original order
+ * @throws {ParameterError} If `concurrency` is not a positive integer or Infinity
+ * @throws {DOMException} If the abort signal is triggered
+ */
+export declare function asyncSettle<T, R>(array: T[], options: {
+    concurrency?: number;
+    mapper: (element: T, index: number) => Promise<R> | R;
+    signal?: AbortSignal;
+}): Promise<({
+    status: 'fulfilled';
+    value: R;
+} | {
+    status: 'rejected';
+    reason: unknown;
+})[]>;
+declare const doneValue: unique symbol;
+/**
+ * Internal interface for resolving asyncWaitFor with a specific value.
+ * @template T - The type of the resolved value
+ */
+interface ResolveWithValue<T> {
+    [doneValue]: T;
+}
+/**
+ * Options for waitFor timeout behavior.
+ * @template T - The type of the fallback return value
+ */
+export interface WaitForTimeoutOptions<T> {
+    /** Timeout duration in milliseconds */
+    readonly ms: number;
+    /** Optional fallback function to call on timeout */
+    readonly fallback?: () => T | Promise<T>;
+    /** Optional custom error message or Error object for timeout */
+    readonly message?: string;
+}
+/**
+ * Timeout option type - either a simple number or detailed options.
+ * @template T - The type of the fallback return value
+ */
+export type TimeoutOption<T> = number | WaitForTimeoutOptions<T>;
+/**
+ * Options for asyncWaitFor function.
+ * @template T - The type of the value to resolve with
+ */
+export interface WaitForOptions<T> {
+    /** Interval between condition checks in milliseconds (default: 20) */
+    readonly interval?: number;
+    /** Timeout configuration - either milliseconds or detailed options */
+    readonly timeout?: TimeoutOption<T>;
+    /** Whether to check condition before first delay (default: true) */
+    readonly before?: boolean;
+    /** Optional abort signal for cancellation */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Waits for a condition to become true, polling at specified intervals.
+ *
+ * @param condition - A function that returns true when the wait should end, or an object with doneValue
+ * @param options - Wait options including interval, timeout, and abort signal
+ * @throws {ParameterError} If interval or timeout values are invalid
+ * @throws {DOMException} With 'TimeoutError' if timeout occurs, or 'AbortError' if cancelled
+ */
+export declare function asyncWaitFor(condition: () => boolean | Promise<boolean>, options?: WaitForOptions<void>): Promise<void>;
+/**
+ * Waits for a condition to resolve with a specific value.
+ *
+ * @template T - The type of the value to resolve with
+ * @param condition - A function that returns true, false, or an object with doneValue
+ * @param options - Wait options including interval, timeout, and abort signal
+ * @returns The value from doneValue if condition returns one, otherwise undefined
+ * @throws {ParameterError} If interval or timeout values are invalid, or condition returns invalid type
+ * @throws {DOMException} With 'TimeoutError' if timeout occurs, or 'AbortError' if cancelled
+ */
+export declare function asyncWaitFor<T>(condition: () => (boolean | ResolveWithValue<T>) | Promise<boolean | ResolveWithValue<T>>, options?: WaitForOptions<T>): Promise<T>;
+export declare namespace asyncWaitFor {
+    var done: <T>(value: T) => ResolveWithValue<T>;
+}
+export {};

package/dist/types/Concurrent/ext/race.d.ts

@@ -0,0 +1,31 @@
+import { MaybePromise } from '../../Utils/type-tool';
+type RaceExecutor<T> = (signal?: AbortSignal) => MaybePromise<T>[];
+/**
+ * Race multiple tasks and return the result of the first settled task (resolve or reject).
+ *
+ * Accepts either an array of tasks or an executor function that returns an array of tasks.
+ * When the first task settles, all other pending tasks are aborted via the provided AbortSignal.
+ *
+ * @template T - The type of the resolved value.
+ * @param executor_or_tasks - An array of tasks (each can be a value or a Promise-like), or a function that receives an AbortSignal and returns such an array.
+ * @returns A Promise that resolves or rejects with the result of the first settled task.
+ * @throws {ParameterError} If the provided tasks array is empty or not an array.
+ */
+export declare function asyncRace<T>(executor_or_tasks: MaybePromise<T>[] | RaceExecutor<T>): Promise<T>;
+type FirstSource<T> = Iterable<MaybePromise<T>> | AsyncIterable<MaybePromise<T>>;
+/**
+ * Resolves with the first successfully fulfilled value from an (async) iterable source.
+ *
+ * Iterates over the source sequentially, starting each task (each element may be a value or a Promise-like).
+ * If any task resolves successfully, that value becomes the result and all remaining tasks are aborted.
+ * If all tasks reject, the function rejects with the last error encountered.
+ *
+ * @template T - The type of the resolved value.
+ * @param source - An iterable or async iterable where each item can be a value or a Promise-like.
+ * @param signal - Optional AbortSignal to cancel the operation externally.
+ * @returns A Promise that resolves with the first successful value, or rejects if all fail or no tasks are provided.
+ * @throws {ParameterError} If the source yields no tasks (empty iterable).
+ * @throws {DOMException} If the provided signal is already aborted (synchronously).
+ */
+export declare function asyncFirst<T>(source: FirstSource<T>, signal?: AbortSignal): Promise<T>;
+export {};

package/dist/types/Concurrent/ext/some.d.ts

@@ -0,0 +1,64 @@
+import { MaybePromise } from '../../Utils/type-tool';
+interface EveryOptions {
+    readonly concurrency?: number;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Tests whether all elements in the iterable pass the test implemented by the provided predicate.
+ * Executes predicates concurrently with a configurable concurrency limit.
+ *
+ * Short-circuits immediately when any predicate returns `false` or throws.
+ *
+ * @template T - The type of elements in the iterable
+ * @param iterable - An iterable of promises resolving to values
+ * @param predicate - A function to test each element
+ * @param options - Configuration options
+ * @returns `true` if all elements pass the predicate, `false` otherwise
+ * @throws {ParameterError} If concurrency is invalid
+ * @throws {DOMException} If the abort signal is triggered
+ */
+export declare function asyncEvery<T>(iterable: Iterable<Promise<T>>, predicate: (value: T, index: number) => MaybePromise<boolean>, options?: EveryOptions): Promise<boolean>;
+interface SomeOptions<T> {
+    readonly count?: number;
+    readonly concurrency?: number;
+    readonly filter?: (value: T) => MaybePromise<boolean>;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Collects elements that satisfy the filter predicate until the specified count is reached.
+ * Executes filters concurrently with a configurable concurrency limit.
+ *
+ * Short-circuits immediately when enough elements are found.
+ *
+ * @template T - The type of elements in the iterable
+ * @param iterable - An iterable of promises resolving to values
+ * @param options - Configuration options including count, concurrency, filter, and abort signal
+ * @returns An array of elements that passed the filter, with length equal to `count`
+ * @throws {ParameterError} If count or concurrency is invalid
+ * @throws {RangeError} If the iterable contains fewer elements than `count`
+ * @throws {AggregateError} If insufficient elements pass the filter
+ * @throws {DOMException} If the abort signal is triggered
+ */
+export declare function asyncSome<T>(iterable: Iterable<Promise<T>>, options: SomeOptions<T>): Promise<T[]>;
+interface AnyOptions<T> {
+    readonly concurrency?: number;
+    readonly filter?: (value: T) => MaybePromise<boolean>;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Returns the first element that satisfies the filter predicate.
+ * Executes filters concurrently with a configurable concurrency limit.
+ *
+ * Short-circuits immediately when a matching element is found.
+ * Similar to Promise.any but with support for filtering and concurrency control.
+ *
+ * @template T - The type of elements in the iterable
+ * @param iterable - An iterable of promises resolving to values
+ * @param options - Configuration options including concurrency, filter, and abort signal
+ * @returns The first element that passed the filter
+ * @throws {ParameterError} If concurrency is invalid
+ * @throws {AggregateError} If no elements pass the filter or all promises reject
+ * @throws {DOMException} If the abort signal is triggered
+ */
+export declare function asyncAny<T>(iterable: Iterable<Promise<T>>, options?: AnyOptions<T>): Promise<T>;
+export {};