import { PWF } from '../PWF';
import { ModelAnalyticsData } from '../PWFTypes';
import type { DownloadMetaData } from '../../procoregl/Models/Models';
import { PWFModelParser } from './PWFModelParser';
import { PWFNode } from './interface/PWFNode';
import { PWFMeshnode } from './interface/PWFMeshnode';
import { PWFMesh } from './interface/PWFMesh';
import { MeshServices } from './standard/MeshServices';
import { StreamedMeshServices } from './streaming/StreamedMeshServices';
import { NodeServices } from './standard/NodeServices';
import { MeshnodeServices } from './standard/MeshnodeServices';
import { StreamedMeshnodeServices } from './streaming/StreamedMeshnodeServices';
import { BVHTree } from '../../procoregl/BVHTree';
import { Node } from './standard/Node';
import { Meshnode } from './standard/Meshnode';
import { PartitionProxy } from './streaming/PartitionProxy';
import { StreamedGeometryFactory } from '../../procoregl/StreamedGeometryFactory';
import { MeshObject } from './objects/MeshObject';
import { MeshnodeObject } from './objects/MeshnodeObject';
import { LRUCache } from '../../utils/LRUCache';
import { Partition } from './streaming/Partition';
import { GeometryFactory } from '../../procoregl/GeometryFactory';
import type { BootstrapperResult } from '../../controllers/Bootstrapper';
import { Vector3 } from '../../types/Math';
import type { ValidatedFeatureFlags } from '../../types/WebviewerOptions';
import type { ResourceDiscriminator } from '../../Webviewer';
export declare class PWFV1 implements PWF {
    private readonly downloadMetaData;
    resourceId: number;
    resource: ResourceDiscriminator;
    streaming: boolean;
    nodeAB?: ArrayBuffer;
    meshnodeAB?: ArrayBuffer;
    meshAB?: ArrayBuffer;
    partitionProxiesAB?: ArrayBuffer;
    pwfModelParser?: PWFModelParser;
    private _numMeshnodes;
    private _numMeshes;
    private _numNodes;
    private globalOffsetValue;
    pwfModel: {
        nodes: PWFNode[];
        meshnodes: PWFMeshnode[];
        meshes: PWFMesh[];
    };
    meshServices?: MeshServices | StreamedMeshServices;
    nodeServices?: NodeServices;
    meshnodeServices?: MeshnodeServices | StreamedMeshnodeServices;
    bvhTree?: BVHTree;
    _virtualMeshnodeIndexOffset: number;
    private readonly featureFlags;
    loadPartitionPromises: Promise<void>[];
    currentIndex: number;
    partitionProxies: PartitionProxy[];
    partitionsCache: LRUCache<string, Partition>;
    private meshServicesOPFSInitialized;
    constructor(params: {
        downloadMetaData: DownloadMetaData;
        resourceId: number;
        resource: ResourceDiscriminator;
        featureFlags: ValidatedFeatureFlags;
    });
    setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
    setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionProxiesAB: ArrayBuffer): void;
    getPwfPartitionContentUrls(): string[];
    initPwfParser(): void;
    parsePwfNodes(): BootstrapperResult;
    parsePwfMeshnodes(): BootstrapperResult;
    parsePwfMeshes(): void;
    initMeshServices(): BootstrapperResult;
    initNodeServices(): void;
    initMeshnodeServices(): void;
    initNodeTree(): BootstrapperResult;
    initNodeTreeBoundingBoxes(): BootstrapperResult;
    allMeshnodes(): Meshnode[];
    getMeshnodeFromIndex(index: number): Meshnode;
    getParentNodeIds(nodeId: number): number[];
    getNodeById(id: number): Node;
    hasNode(id: number): boolean;
    private crawlAndCollectParentNodeIds;
    getSubtreeNodeIds(nodeId: number): number[];
    getVirtualMeshnodeIndexesByNodeId(nodeId: number): number[];
    private crawlAndCollectSubtreeNodeIds;
    private getSubTreeVirtualMeshnodeIndexes;
    getMeshnodeFromNodeId(nodeId: number): Meshnode;
    getMeshnode(offset: number): Meshnode;
    getNode(offset: number): Node | Meshnode;
    numNodes(): number;
    numMeshnodes(): number;
    numMeshes(): number;
    loadAllMeshGeometryToGPU(): BootstrapperResult;
    loadAllPartitionProxies(): void;
    prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
    setGeometryFactory(geometryFactory: GeometryFactory): void;
    globalOffset(): Vector3;
    root(): Node;
    forEachMeshnode(callback: (meshnode: Meshnode) => void): void;
    forEachNode(callback: (node: Node) => void): void;
    getMeshObject(meshRef: number): MeshObject;
    findFirstObject(meshnodeIndex: number): Node;
    numFirstObjects(): number;
    breadthFirstTraversalNodes(callback: (n: Node | Meshnode) => void): BootstrapperResult;
    getNamedNode(nodeId: number): Node;
    getMeshDataForPartitionedModel(meshnodeIndex: number): Promise<MeshnodeObject>;
    captureModelStats(): number;
    private captureStandardModelStats;
    private capturePartitionedModelStats;
    getModelAnalyticsData(): ModelAnalyticsData;
    get virtualMeshnodeIndexOffset(): number;
    set virtualMeshnodeIndexOffset(value: number);
    dispose(): void;
}
