import { type ViralutionElement } from "../..";
import type { ViralViewerApi } from "../../viral-viewer-api";
export declare class ViralRevitLoader {
    viralViewerApi: ViralViewerApi;
    elements: ViralutionElement[];
    private _loadBatchedElementWorker;
    constructor(viralViewerApi: ViralViewerApi);
    load(trackingUrl: string, dataUrl: string, informationUrl: string, callbackOnFinish?: () => void): Promise<void>;
    private getCachedMaterials;
    private getCachedChunk;
    getMaterials(dataUrl: string, byteRangeStart: number, byteRangeEnd: number, type?: string): Promise<any>;
    /**
     * Fetch + decompress + parse BIM information entirely off the main thread.
     *
     * Network fetch runs in existing fetch-data worker,
     * then decompression (DecompressionStream) + JSON.parse run in a one-shot
     * inline worker so the main thread stays free for Three.js rendering.
     */
    private fetchBIMInformationOffThread;
    /**
     * Fetch BIM information that was uploaded as concatenated gzip chunks.
     * Each byte-range is an independently gzipped msgpack object containing
     * a subset of BIM properties (key → value). We fetch + decompress + decode
     * each chunk in parallel, then merge all entries into one ViralutionInformation.
     */
    private fetchBIMInformationChunked;
    /**
     * Stream-decompress a gzipped MessagePack buffer using native DecompressionStream
     * and decode it incrementally with msgpack's decodeAsync.
     * Avoids loading the entire decompressed buffer into memory at once,
     * and avoids blocking the main thread — handles 73 MB+ files safely.
     */
    private decompressAndDecodeMsgpackStream;
    /**
     * Offload ArrayBuffer decompression + JSON.parse to a disposable worker.
     * Uses native DecompressionStream (no pako dependency in worker),
     * tries deflate/gzip/deflate-raw formats automatically.
     * The ArrayBuffer is transferred (zero-copy) to the worker.
     */
    private decompressAndParseOffThread;
    /**
     * Fetch a single byte-range chunk, decompress (pako), and parse into elements.
     */
    private fetchAndDecompressChunk;
    /**
     * Sequential async generator — yields element chunks one at a time.
     * Use getElementChunksParallel() for maximum throughput.
     */
    getElementChunks(dataUrl: string, chunk: number[][]): AsyncGenerator<{
        elements: ViralutionElement[];
        index: number;
    }>;
    /**
     * 🚀 Streaming parallel chunk loader.
     * Fires ALL chunk fetches simultaneously via HTTP/2 multiplexing
     * and yields each result as its fetch completes (completion order,
     * NOT array order). This maximizes network throughput.
     *
     * @param concurrency Max parallel fetches (default: all chunks at once)
     */
    getElementChunksParallel(dataUrl: string, chunk: number[][], concurrency?: number): AsyncGenerator<{
        elements: ViralutionElement[];
        index: number;
    }>;
    /**
     * @deprecated Use getElementChunks() async generator instead
     */
    getElements(dataUrl: string, chunk: number[][], callbackOnSuccess?: (model: any, index: number) => void): Promise<void>;
    getTranslation(translation: number[]): {
        x: number;
        y: number;
        z: number;
    } | null;
    /**
     * dispose all current model
     */
    disposeModels(): void;
    /**
     * Dispose worker pools held by the revit loader.
     */
    dispose(): void;
}
