/**
 * Logger interface for ConcurrencyManager
 */
export interface ConcurrencyLogger {
    info: (message: string, meta?: Record<string, unknown>) => void;
    warn: (message: string, meta?: Record<string, unknown>) => void;
    error: (message: string, meta?: Record<string, unknown>) => void;
}
export declare const setConcurrencyLogger: (logger: ConcurrencyLogger) => void;
/**
 * ConcurrencyManager - Manages concurrent request slots with mutex-based synchronization
 *
 * Prevents resource exhaustion by limiting the number of concurrent expensive operations.
 * Uses async-mutex for atomic slot acquisition/release.
 *
 * @example
 * ```typescript
 * const manager = new ConcurrencyManager(3); // Max 3 concurrent requests
 *
 * async function expensiveOperation() {
 *   await manager.acquireSlot();
 *   try {
 *     // ... expensive operation ...
 *   } finally {
 *     manager.releaseSlot();
 *   }
 * }
 * ```
 */
export declare class ConcurrencyManager {
    private readonly maxConcurrentRequests;
    private activeSynthesisRequests;
    private readonly requestQueue;
    private readonly slotMutex;
    constructor(maxConcurrentRequests?: number);
    /**
     * Acquire a slot for concurrent execution
     * Blocks until a slot is available or timeout occurs (5 seconds)
     */
    acquireSlot(): Promise<void>;
    /**
     * Release a slot and process next queued request
     */
    releaseSlot(): void;
    /**
     * Get current number of active requests
     */
    getActiveCount(): number;
    /**
     * Get current queue length
     */
    getQueueLength(): number;
    /**
     * Get max concurrent requests allowed
     */
    getMaxConcurrent(): number;
    /**
     * Execute a function with automatic slot management
     *
     * @example
     * ```typescript
     * const result = await manager.execute(async () => {
     *   return await expensiveOperation();
     * });
     * ```
     */
    execute<T>(fn: () => Promise<T>): Promise<T>;
}
//# sourceMappingURL=ConcurrencyManager.d.ts.map