/**
 * Append-only buffer for streaming voxelization results.
 * Stores block masks using Morton codes for efficient octree construction.
 *
 * Backed by typed arrays that grow geometrically. Morton codes use
 * Float64Array (51 bits of precision needed; exceeds Smi range), and
 * voxel masks use Uint32Array. This raises the per-buffer capacity well
 * above V8's regular-array backing-store limit so very large grids can
 * round-trip without throwing `RangeError: Invalid array length`.
 *
 * Buffers start at length 0 and the first `addBlock` allocates
 * `INITIAL_CAPACITY` entries; subsequent grows double. A freshly cleared
 * instance therefore retains no allocations until it is reused.
 */
declare class BlockMaskBuffer {
    /** Morton codes for solid blocks (mask is implicitly all 1s) */
    private _solidMorton;
    private _solidCount;
    private _solidCap;
    /** Morton codes for mixed blocks */
    private _mixedMorton;
    private _mixedCount;
    private _mixedCap;
    /** Interleaved voxel masks for mixed blocks: [lo0, hi0, lo1, hi1, ...] */
    private _mixedMasks;
    /**
     * Add a non-empty block to the buffer.
     * Automatically classifies as solid or mixed based on mask values.
     *
     * @param morton - Morton code encoding block position
     * @param lo - Lower 32 bits of voxel mask
     * @param hi - Upper 32 bits of voxel mask
     */
    addBlock(morton: number, lo: number, hi: number): void;
    /**
     * Get all mixed blocks as views into the underlying buffers.
     * Index `i` of `morton` corresponds to mask pair `(masks[i*2], masks[i*2+1])`.
     *
     * @returns Object with morton codes and interleaved masks
     */
    getMixedBlocks(): {
        morton: Float64Array;
        masks: Uint32Array;
    };
    /**
     * Get all solid blocks as a view into the underlying buffer.
     *
     * @returns Array of Morton codes
     */
    getSolidBlocks(): Float64Array;
    /**
     * Get total number of blocks stored.
     *
     * @returns Count of mixed + solid blocks
     */
    get count(): number;
    /**
     * Get number of mixed blocks.
     *
     * @returns Count of mixed blocks
     */
    get mixedCount(): number;
    /**
     * Get number of solid blocks.
     *
     * @returns Count of solid blocks
     */
    get solidCount(): number;
    /**
     * Clear all buffered blocks. Releases the underlying buffers so a cleared
     * instance does not retain peak memory; the next `addBlock` re-allocates
     * to `INITIAL_CAPACITY`.
     */
    clear(): void;
}
export { BlockMaskBuffer };
