/**
 * Pre-allocated scratch reused across every `fm_kway` call during the
 * uncoarsening / refinement phase.
 *
 * `refine_kway` invokes `fm_kway` once per multilevel level (typically 3-15
 * times per partition run). Each call previously allocated:
 *   - one `IndexedFloatMaxHeap` (with a `Uint32Array(vertex_count)` index table —
 *     4 MB at 1M vertices)
 *   - three vertex-sized typed arrays for queue status and touched bookkeeping
 *   - two partition-count-sized arrays for the weight bounds
 *
 * Sharing one set of arrays scoped to the original (finest) graph's vertex
 * count means the heap's index table is sized once and the rest of the state
 * is reused across all levels.
 *
 * The arrays' invariants are preserved across calls without explicit clears:
 *
 *   - `queue_status` starts all-0 (NOT_PRESENT). Each fm_kway pass resets
 *     touched entries back to 0 in its cleanup, so subsequent calls see a
 *     clean slate without needing a fresh `.fill(0)`.
 *
 *   - `touched_position_of_vertex` starts all -1. Same per-pass cleanup
 *     restores -1 for every touched entry.
 *
 *   - The heap uses `.clear()` at the start of each pass — that's O(size),
 *     not O(capacity), and resets `__slot_of_id` only for the entries actually
 *     in the heap.
 */
export class RefinementScratch {
    /**
     * @param {number} max_vertex_count typically the original (finest) graph's vertex count
     * @param {number} partition_count
     */
    constructor(max_vertex_count: number, partition_count: number);
    max_vertex_count: number;
    partition_count: number;
    move_queue: IndexedFloatMaxHeap;
    queue_status: Uint8Array;
    touched_vertices: Uint32Array;
    touched_position_of_vertex: Int32Array;
    partition_weight_min: Uint32Array;
    partition_weight_max: Uint32Array;
}
import { IndexedFloatMaxHeap } from "./IndexedFloatMaxHeap.js";
//# sourceMappingURL=RefinementScratch.d.ts.map