/**
 * Lane-based Concurrency Manager
 *
 * Implements a queue system for managing concurrent task execution.
 * Based on OpenClaw's command-queue.js pump pattern.
 *
 * Key features:
 * - Session lanes: Ensure same-session messages are processed in order
 * - Global lane: Limit total concurrent API calls (rate limit protection)
 * - 2-stage queueing: Session lane → Global lane
 *
 * @example
 * ```typescript
 * const manager = new LaneManager();
 *
 * // Simple enqueue
 * const result = await manager.enqueue('session:user1', async () => {
 *   return await callApi();
 * });
 *
 * // 2-stage queueing (session → global)
 * const result = await manager.enqueueWithSession('user1', async () => {
 *   return await callApi();
 * });
 * ```
 */
import { type LaneManagerConfig, type EnqueueOptions } from './types.js';
export declare class LaneManager {
    private lanes;
    private config;
    constructor(config?: LaneManagerConfig);
    /**
     * Get or create lane state
     */
    private getLaneState;
    /**
     * Drain lane queue using pump pattern
     * Executes tasks up to maxConcurrent limit
     */
    private drainLane;
    /**
     * Enqueue a task in a lane
     *
     * @param lane - Lane identifier
     * @param task - Async task to execute
     * @param options - Enqueue options
     * @returns Promise that resolves with task result
     */
    enqueue<T>(lane: string, task: () => Promise<T>, options?: EnqueueOptions): Promise<T>;
    /**
     * Resolve session lane name from session key
     * Ensures consistent naming: "user1" → "session:user1"
     */
    resolveSessionLane(sessionKey: string): string;
    /**
     * Resolve global lane name
     * Returns "main" if not specified
     */
    resolveGlobalLane(lane?: string): string;
    /**
     * 2-stage queueing: Session lane → Global lane
     *
     * This ensures:
     * 1. Same-session messages are processed in order (session lane)
     * 2. Total API calls are rate-limited (global lane)
     *
     * @param sessionKey - Session identifier (will be prefixed with "session:")
     * @param task - Async task to execute
     * @param globalLane - Global lane name (default: "main")
     */
    enqueueWithSession<T>(sessionKey: string, task: () => Promise<T>, globalLane?: string): Promise<T>;
    /**
     * Set max concurrent tasks for a lane
     */
    setLaneMaxConcurrent(lane: string, maxConcurrent: number): void;
    /**
     * Get current queue size for a lane
     * Includes both queued and active tasks
     */
    getQueueSize(lane: string): number;
    /**
     * Get total queue size across all lanes
     */
    getTotalQueueSize(): number;
    /**
     * Clear all pending tasks in a lane
     * Active tasks continue to completion
     *
     * @returns Number of tasks removed
     */
    clearLane(lane: string): number;
    /**
     * Get all lane names
     */
    getLanes(): string[];
    /**
     * Get lane statistics
     */
    getStats(): Map<string, {
        queued: number;
        active: number;
        maxConcurrent: number;
    }>;
}
/**
 * Get or create global LaneManager instance
 */
export declare function getGlobalLaneManager(config?: LaneManagerConfig): LaneManager;
/**
 * Reset global LaneManager (mainly for testing)
 */
export declare function resetGlobalLaneManager(): void;
//# sourceMappingURL=lane-manager.d.ts.map