/**
 * Concurrency utilities for parallel execution with limits.
 */
/**
 * Options for parallel execution.
 */
export interface ParallelOptions<T> {
    /** Maximum concurrent tasks (default: 3) */
    concurrency?: number;
    /** Timeout per task in milliseconds (default: no timeout) */
    taskTimeoutMs?: number;
    /** Callback when a task completes */
    onTaskComplete?: (result: T, index: number) => void;
    /** Callback when a task fails */
    onTaskError?: (error: Error, index: number) => void;
}
/**
 * Result of a parallel execution.
 */
export interface ParallelResult<T> {
    /** Successful results */
    results: T[];
    /** Errors by index */
    errors: Map<number, Error>;
    /** Whether all tasks succeeded */
    allSucceeded: boolean;
}
/**
 * Execute tasks in parallel with a concurrency limit.
 * Uses a semaphore pattern to limit concurrent execution.
 *
 * @param tasks - Array of async task functions to execute
 * @param options - Parallel execution options
 * @returns Results of all tasks
 */
export declare function parallelLimit<T>(tasks: Array<() => Promise<T>>, options?: ParallelOptions<T>): Promise<ParallelResult<T>>;
/**
 * Execute tasks in parallel with a concurrency limit, collecting all results.
 * Unlike parallelLimit, this version preserves order and includes errors inline.
 *
 * @param items - Array of items to process
 * @param fn - Async function to process each item
 * @param options - Parallel execution options
 * @returns Array of results (or errors) in original order
 */
export declare function mapLimit<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, options?: ParallelOptions<R>): Promise<Array<{
    success: true;
    value: R;
} | {
    success: false;
    error: Error;
}>>;
/**
 * Create a semaphore for limiting concurrent access to a resource.
 */
export declare function createSemaphore(limit: number): {
    acquire(): Promise<void>;
    release(): void;
    readonly available: number;
    readonly waiting: number;
};
/**
 * Mutex for ensuring exclusive access to a resource.
 */
export declare function createMutex(): {
    acquire(): Promise<void>;
    release(): void;
    readonly available: number;
    readonly waiting: number;
};
/**
 * Thread-safe accumulator for collecting results from parallel tasks.
 */
export declare class SafeAccumulator<T> {
    private items;
    private mutex;
    /**
     * Add an item to the accumulator.
     */
    add(item: T): Promise<void>;
    /**
     * Add multiple items to the accumulator.
     */
    addAll(items: T[]): Promise<void>;
    /**
     * Get all accumulated items.
     */
    getAll(): T[];
    /**
     * Get the current count.
     */
    get count(): number;
}
/**
 * Thread-safe map for collecting keyed results.
 */
export declare class SafeMap<K, V> {
    private map;
    private mutex;
    /**
     * Set a value in the map.
     */
    set(key: K, value: V): Promise<void>;
    /**
     * Get a value from the map.
     */
    get(key: K): V | undefined;
    /**
     * Check if a key exists.
     */
    has(key: K): boolean;
    /**
     * Get all entries.
     */
    entries(): IterableIterator<[K, V]>;
    /**
     * Get all values.
     */
    values(): IterableIterator<V>;
    /**
     * Get the current size.
     */
    get size(): number;
}
//# sourceMappingURL=concurrency.d.ts.map