/**
 * MinHeap/PriorityQueue implementation optimized for Dijkstra's algorithm.
 * Items with lowest priority are extracted first.
 */
declare class MinHeap<T> {
    private readonly _heap;
    private readonly _tieBreaker;
    /**
     * Creates an empty MinHeap.
     *
     * @param options - Configuration options.
     *   `tieBreaker`: comparator invoked when two entries have equal priority.
     *   Negative return = a wins (comes out first).
     *   When omitted, equal-priority extraction order is unspecified (heap-natural).
     */
    constructor(options?: {
        tieBreaker?: (a: T, b: T) => number;
    });
    /** Insert an item with given priority. */
    insert(item: T, priority: number): void;
    /** Extract and return the item with minimum priority. */
    extractMin(): T | undefined;
    /** Check if the heap is empty. */
    isEmpty(): boolean;
    /** Get the number of items in the heap. */
    size(): number;
    /** Peek at the minimum priority without removing the item. */
    peekPriority(): number;
    /**
     * Compares two heap entries. Returns negative if a should come before b.
     */
    private _compare;
    /** Restore heap property by bubbling up from index. */
    private _bubbleUp;
    /**
     * Finds the index of the smallest among parent, left child, and right child.
     */
    private _smallestChild;
    /** Restore heap property by bubbling down from index. */
    private _bubbleDown;
}
export default MinHeap;
