import { HydrationBoundaryId, HydrationPriority, HydrationTask } from './types';
/**
 * Comparison result for queue ordering.
 * Negative = a comes before b, Positive = b comes before a, Zero = equal
 */
type CompareResult = -1 | 0 | 1;
/**
 * Comparator function for priority queue ordering.
 */
type TaskComparator = (a: HydrationTask, b: HydrationTask) => CompareResult;
/**
 * Filter predicate for queue operations.
 */
type TaskPredicate = (task: HydrationTask) => boolean;
/**
 * Configuration for the priority queue.
 */
export interface PriorityQueueConfig {
    /** Maximum queue capacity (0 = unlimited) */
    readonly maxSize: number;
    /** Custom comparator (default: by priority weight then enqueue time) */
    readonly comparator?: TaskComparator;
    /** Callback when queue overflows */
    readonly onOverflow?: (droppedTask: HydrationTask) => void;
}
/**
 * Binary min-heap priority queue for hydration tasks.
 *
 * @example
 * ```typescript
 * const queue = new HydrationPriorityQueue({ maxSize: 100 });
 *
 * queue.insert(task1);
 * queue.insert(task2);
 *
 * while (!queue.isEmpty()) {
 *   const task = queue.extractMin();
 *   await task.hydrate();
 * }
 * ```
 */
export declare class HydrationPriorityQueue {
    /** The heap array */
    private heap;
    /** Index lookup for O(1) task finding */
    private indexMap;
    /** Queue configuration */
    private readonly config;
    /**
     * Creates a new priority queue.
     *
     * @param config - Queue configuration
     */
    constructor(config?: Partial<PriorityQueueConfig>);
    /**
     * Returns the number of tasks in the queue.
     */
    get size(): number;
    /**
     * Returns whether the queue is empty.
     */
    isEmpty(): boolean;
    /**
     * Returns whether the queue is full.
     */
    isFull(): boolean;
    /**
     * Inserts a task into the queue.
     * If queue is full, drops the lowest priority task.
     *
     * @param task - Task to insert
     * @returns true if inserted, false if dropped due to lower priority
     */
    insert(task: HydrationTask): boolean;
    /**
     * Inserts multiple tasks efficiently.
     *
     * @param tasks - Tasks to insert
     * @returns Number of tasks successfully inserted
     */
    insertMany(tasks: readonly HydrationTask[]): number;
    /**
     * Returns the highest priority task without removing it.
     *
     * @returns The highest priority task, or undefined if empty
     */
    peek(): HydrationTask | undefined;
    /**
     * Removes and returns the highest priority task.
     *
     * @returns The highest priority task, or undefined if empty
     */
    extractMin(): HydrationTask | undefined;
    /**
     * Extracts multiple high-priority tasks.
     *
     * @param count - Maximum number of tasks to extract
     * @returns Array of extracted tasks
     */
    extractMany(count: number): HydrationTask[];
    /**
     * Removes a specific task from the queue.
     *
     * @param id - ID of the task to remove
     * @returns The removed task, or undefined if not found
     */
    remove(id: HydrationBoundaryId): HydrationTask | undefined;
    /**
     * Updates the priority of a task.
     *
     * @param id - ID of the task to update
     * @param newPriority - New priority level
     * @returns true if updated, false if not found
     */
    updatePriority(id: HydrationBoundaryId, newPriority: HydrationPriority): boolean;
    /**
     * Checks if a task exists in the queue.
     *
     * @param id - ID of the task to check
     * @returns true if task exists
     */
    has(id: HydrationBoundaryId): boolean;
    /**
     * Gets a task by ID without removing it.
     *
     * @param id - ID of the task to get
     * @returns The task, or undefined if not found
     */
    get(id: HydrationBoundaryId): HydrationTask | undefined;
    /**
     * Removes all tasks matching a predicate.
     *
     * @param predicate - Filter function
     * @returns Array of removed tasks
     */
    removeWhere(predicate: TaskPredicate): HydrationTask[];
    /**
     * Returns all tasks matching a predicate.
     *
     * @param predicate - Filter function
     * @returns Array of matching tasks (not removed)
     */
    filter(predicate: TaskPredicate): HydrationTask[];
    /**
     * Returns tasks by priority level.
     *
     * @param priority - Priority to filter by
     * @returns Array of tasks with the specified priority
     */
    getByPriority(priority: HydrationPriority): HydrationTask[];
    /**
     * Clears all tasks from the queue.
     */
    clear(): void;
    /**
     * Returns an iterator over tasks in priority order.
     * Note: This is destructive - it extracts all tasks.
     */
    drain(): Generator<HydrationTask, void, unknown>;
    /**
     * Returns a non-destructive iterator over tasks.
     * Note: Order is not guaranteed to be priority order.
     */
    [Symbol.iterator](): Iterator<HydrationTask>;
    /**
     * Converts to array (non-destructive).
     * Note: Order is not guaranteed to be priority order.
     */
    toArray(): HydrationTask[];
    /**
     * Returns a sorted array of all tasks.
     * Note: This is O(n log n) and creates a new array.
     */
    toSortedArray(): HydrationTask[];
    /**
     * Returns queue statistics.
     */
    getStats(): PriorityQueueStats;
    /**
     * Bubbles up an element to maintain heap property.
     */
    private bubbleUp;
    /**
     * Bubbles down an element to maintain heap property.
     */
    private bubbleDown;
    /**
     * Swaps two elements in the heap.
     */
    private swap;
    /**
     * Peeks at the lowest priority task.
     * Note: This is O(n) as lowest priority can be any leaf.
     */
    private peekLowestPriority;
    /**
     * Extracts the lowest priority task.
     */
    private extractLowestPriority;
}
/**
 * Statistics about the priority queue.
 */
export interface PriorityQueueStats {
    /** Current queue size */
    readonly size: number;
    /** Maximum queue size */
    readonly maxSize: number;
    /** Count by priority level */
    readonly byPriority: Record<HydrationPriority, number>;
    /** Oldest enqueue timestamp */
    readonly oldestEnqueueTime: number | null;
    /** Newest enqueue timestamp */
    readonly newestEnqueueTime: number | null;
}
/**
 * Creates a new priority queue with default configuration.
 *
 * @param maxSize - Maximum queue size (default: 1000)
 * @returns A new priority queue instance
 */
export declare function createPriorityQueue(maxSize?: number): HydrationPriorityQueue;
/**
 * Creates a priority queue pre-populated with tasks.
 *
 * @param tasks - Initial tasks
 * @param config - Queue configuration
 * @returns A new priority queue with tasks inserted
 */
export declare function createPriorityQueueFrom(tasks: readonly HydrationTask[], config?: Partial<PriorityQueueConfig>): HydrationPriorityQueue;
export {};