export function RenderController(params: any): void;
export class RenderController {
    constructor(params: any);
    params: any;
    logInitializationTimes: any;
    cameras: {
        default: import("three").PerspectiveCamera;
        global: import("three").PerspectiveCamera;
        old: {
            position: import("three").Vector3;
            rotation: import("three").Vector3;
        };
    };
    scenes: {
        default: import("three").Scene;
    };
    controls: any;
    frameId: number | null;
    measureEnabled: boolean;
    canvasSelectionEnabled: boolean;
    globalOffset: import("../sdk").Vector3 | null;
    clock: import("three").Clock;
    delta: number;
    webengine: import("../../webassembly/webengine/dist/webengine").InitOutput | null;
    webenginePromise: Promise<import("../../webassembly/webengine/dist/webengine").InitOutput>;
    enableWebWorker: any;
    prefetchingPartitions: boolean;
    projectId: any;
    baseUrl: any;
    meshnodeABCached: boolean;
    nodeABCached: boolean;
    meshABCached: boolean;
    trackingController: StatusTrackingController;
    zoomExtentsParams: {
        zoomExtents: {
            zenith: number;
            azimuth: number;
            distanceFromCenterFactor: number;
        };
    };
    zoomToGlobalParams: {
        spaceJunkEliminationThreshold: number;
    };
    initCanvas(): void;
    streaming: boolean | undefined;
    viewerRenderer: import("../procoregl/ViewerRenderer").ViewerRenderer | undefined;
    textures: {
        picking: import("three").WebGLRenderTarget;
    } | undefined;
    section: SectionController | undefined;
    composer: EffectComposer | undefined;
    procoreRenderPass: ProcoreRenderPass | undefined;
    sectionRenderPass: SectionRenderPass | undefined;
    pickingController: PickingController | undefined;
    initWasm(): Promise<void>;
    parsePwfNodes(): import("./Bootstrapper").BootstrapperResult;
    parsePwfMeshnodes(): import("./Bootstrapper").BootstrapperResult;
    parsePwfMeshes(): void;
    initMeshServices(): import("./Bootstrapper").BootstrapperResult;
    initNodeServices(): void;
    initMeshnodeServices(): void;
    initNodeTree(): import("./Bootstrapper").BootstrapperResult;
    initNodeTreeBoundingBoxes(): import("./Bootstrapper").BootstrapperResult;
    initSceneGraph(): import("./Bootstrapper").BootstrapperResult;
    initGlobalOffset(): void;
    pointToPointController: PointToPointController | undefined;
    initGeometryFactory(): void;
    initTreeServices(): import("./Bootstrapper").BootstrapperResult;
    initViewerRenderer(): void;
    initGeometry(): import("./Bootstrapper").BootstrapperResult;
    initGlobalBoundingBox(): void;
    initNavigationModel(): void;
    navigationModel: NavigationModel | undefined;
    initLightingAndShader(): void;
    light: {
        default: import("three").DirectionalLight;
        ambient: import("three").AmbientLight;
    } | null | undefined;
    getInitEventPayload(params: any): import("../api/analytic_events/analyticKeys").ModelInitializationPayload;
    launchAnimationLoop(): void;
    waitTillRenderStage(params: any): Promise<any>;
    captureModelStats(): void;
    init(modelDescriptors: any, downloadMetaData: any): Promise<void>;
    meshnodeAB: any;
    nodeAB: any;
    meshAB: any;
    manifest: any;
    sceneGraphName: any;
    downloadMetaData: any;
    modelDescriptors: any;
    locale: any;
    models: Models | undefined;
    firstModelResourceId: number | undefined;
    pwf: import("../pwfreader/PWFProxy").PWFProxy | undefined;
    shortestDistanceController: ShortestDistanceController | undefined;
    colorServices: ColorServices | undefined;
    onUpdateWithState(data: any): void;
    close(): boolean;
    closed: boolean | undefined;
    renderer: any;
    animate(): void;
    getCameraDirection(): {
        x: number;
        y: number;
        z: number;
    };
    getPosition(params?: {
        applyOffset: boolean;
    }): {
        x: number;
        y: number;
        z: number;
    };
    setMeshnodeColor(params: any): void;
    setNodeColor(palettes: any, options: any): void;
    clearNodeColor(nodeIds: any, options: any): void;
    clearAllNodeColor(options: any): void;
    setLookAt(params: any): {
        direction: {
            x: number;
            y: number;
            z: number;
        };
        position: {
            x: number;
            y: number;
            z: number;
        };
    };
    getLookAt(params?: {}): {
        x: number;
        y: number;
        z: number;
    };
    getBenchmarkPoint(): {
        position: {
            x: number;
            y: number;
            z: number;
        };
        lookAt: {
            x: number;
            y: number;
            z: number;
        };
    };
    setBenchmarkPoint(params: any): void;
    setPosition(params: any): {
        direction: {
            x: number;
            y: number;
            z: number;
        };
        position: {
            x: number;
            y: number;
            z: number;
        };
    };
    getModelItemBoundary(id: any): import("three").Box3;
    getGlobalOffset(): import("../sdk").Vector3 | null;
    getMeshnodeFromNodeId(nodeId: any): import("../pwfreader/PWFTypes").Meshnode | null;
    getMeshnodeFromIndex(id: any): import("../pwfreader/PWFTypes").Meshnode | null;
    getMeasureObjectMeshes(): import("../pwfreader/PWFTypes").MeshnodeObject[];
    getCamera(): import("three").PerspectiveCamera;
    getRenderer(): import("../procoregl/ViewerRenderer").ViewerRenderer | undefined;
    resizeScene(params: any): void;
    getContextMenuData(evt: any): {
        intersection: import("../sdk").Vector3 | null;
        meshnodeIndex: number;
        faceNormal: import("../sdk").Vector3 | null;
    } | {
        meshnodeIndex: number;
    };
    onContextMenu(evt: any): void;
    isSectionBlockingClick(): boolean;
    getIntersectionAndMeshnodeIndex(evt: any): {
        intersection: import("../sdk").Vector3 | null;
        meshnodeIndex: number;
        faceNormal: import("../sdk").Vector3 | null;
    };
    isMeshnodeSelected(virtualMeshnodeIndex: any): boolean;
    clickedOnSelectedObject(virtualMeshnodeIndex: any, rightClick: any): void;
    clickedOnUnselectedObject(virtualMeshnodeIndex: any, rightClick: any): void;
    handleObjectSelection(meshnodeIndex: any, rightClick: any): void;
    handleEmptySpaceClick(): void;
    onSingleClick(evt: any, rightClick?: boolean): void;
    onMouseMove(evt: any): void;
    onWheel(evt: any): void;
    setCanvasSelectionEnabled(enabled: any): void;
    getSelectedSubtree(meshnodeIndex: any): {
        objectId: number;
        selectionContainerId: number | undefined;
        ancestry: {
            children: (import("../sdk").PublicNode | undefined)[];
            id?: number | undefined;
            bbox?: import("../sdk").NodeBoundingBox | undefined;
            nodeType?: number | undefined;
            hidden?: boolean | undefined;
            selected?: boolean | undefined;
            partiallySelected?: boolean | undefined;
            parentId?: number;
        }[];
    };
    onDoubleClick(evt: any): void;
    onRightClick(evt: any): void;
    hideSelected(params?: {}): void;
    unhideNodeFromNodeIds(params: any): boolean;
    hideNodesFromNodeIds(params?: {}): boolean;
    getHiddenNodeIds(params?: {}): number[];
    getHiddenMeshnodeIndices(params?: {}): number[];
    getHiddenGeoIdsSet(params?: {}): Set<number>;
    addHiddenMeshnodeIndices(arr: any, resourceId?: any): void;
    setVisibility(params: any): void;
    getVisibility(params: any): import("../sdk").Visibility;
    getZoomInterSectPoint(evt: any): {
        x: number;
        y: number;
        z: number;
    };
    ToScreenPosition(params: any): import("../sdk").Vector3 | import("../sdk").Vector3[];
    ConvertScreenPosition(vector: any): {
        x: any;
        y: any;
        z: any;
    };
    ModelToMapSpace(params: any): {
        x?: undefined;
        y?: undefined;
        dir_x?: undefined;
        dir_y?: undefined;
    } | {
        x: number;
        y: number;
        dir_x: number;
        dir_y: number;
    };
    MapToModelSpace(params: any): {
        x?: undefined;
        y?: undefined;
        dir_x?: undefined;
        dir_y?: undefined;
    } | {
        x: number;
        y: number;
        dir_x: number;
        dir_y: number;
    };
    setBcfCamera(params: any): false | {
        perspective_camera: {
            camera_view_point: {
                x: number;
                y: number;
                z: number;
            };
            camera_direction: {
                x: number;
                y: number;
                z: number;
            };
            camera_up_vector: {
                x: number;
                y: number;
                z: number;
            };
            field_of_view: number;
            target_distance: number;
            unit: string;
        };
    };
    setCameraRotation(params: any): void;
    sanitizeFieldOfView(fov: any): any;
    getBcfCamera(params?: {
        applyOffset: boolean;
    }): {
        perspective_camera: {
            camera_view_point: {
                x: number;
                y: number;
                z: number;
            };
            camera_direction: {
                x: number;
                y: number;
                z: number;
            };
            camera_up_vector: {
                x: number;
                y: number;
                z: number;
            };
            field_of_view: number;
            target_distance: number;
            unit: string;
        };
    };
    refreshScene(): void;
    setHiddenSet(params: any): void;
    refreshLighting(): void;
    setSectionBox(params: any): void;
    setSectionsData(params: any): boolean;
    removeSectionBox(): void;
    addSectionPlane(params: any): void;
    removeSectionPlane(uuid: any): void;
    getSections(format: any): import("../sdk").SectionDataProcoreFormat | import("../sdk").SectionDataAutodeskFormat | null;
    clearSection(): void;
    setOptions(options: any): void;
    findFirstObject(params: any): import("../sdk").PublicNode | undefined;
    getNamedNode(nodeId: any, options?: {}): import("../sdk").PublicNode | undefined;
    setEulerAngles(params: any): void;
    statusChange(type: any): void;
    onUndo(): void;
    onRedo(): void;
    getOrbitTranslate(event: any): {
        translate: import("../sdk").Vector3 | import("../sdk").Vector3[];
        orbitPoint: import("../sdk").Vector3;
    };
    setMeasureEnabled(enabled: any): void;
    getMeasureEnabled(): boolean;
    getMeasureIds(): number[];
    removeMeasureIds(measureIds: any): void;
    clearMeasureIds(): void;
    hasHiddenMeshnodeIndices(ids: any, options?: {}): boolean;
    clearHidden(options?: {}): boolean;
    getSelectedMeshnodeIndices(options?: {}): number[];
    addSelectedMeshnodeIndices(ids: any, options?: {}): boolean;
    clearAndSelectNode(nodeId: any, options?: {}): void;
    clearAndSelectNodes(params: any): void;
    getNode(params: any): import("../sdk").PublicNode | undefined;
    getNodes(params: any): any;
    getRootNode(params?: {}): import("../sdk").PublicNode | undefined;
    setNodesSelected(params: any): boolean;
    hasSelectedMeshnodeIndices(ids: any, options?: {}): boolean;
    clearSelected(params?: {}): boolean;
    getFieldOfView(): number;
    setFieldOfView(deg: any): void;
    setPose(params: any): void;
    zoomToGlobal(): void;
    zoomToBoundingBox(bbox: any): void;
    getBoundingBoxByMeshnodeIndices(params: any): any;
    zoomToSelection(options?: {}): void;
    isolateSelection(options?: {}): void;
    isolateSelectionInSectionBox(options?: {}): void;
    zoomToNodes(nodeIds: any): void;
    getNumNodesSelected(params?: {}): {
        count: number;
    };
    getNumNodesHidden(options?: {}): {
        count: number;
    };
    setRenderMode(renderMode: any, origin: any): void;
    getRenderMode(): string;
    getSelectedNodeIds(params?: {}): number[];
    toggleSectionBoxDisplay(enable: any): void;
    togglePointToPoint(enabled: any): void;
    getSectionBoxDisplayBbox(): import("../sdk").BoundingBox;
    getSectionsAsBox(): import("../sectioning/SectionController").OrientedBox | null;
    zoomToSectionBox(): void;
    resetSectionBox(): void;
    setSectionBoxHidden(hide: any): void;
    updateSectionHover(event: any): void;
    clearSectionHover(): void;
    isSectionBoxHovered(): boolean;
    resizeSectionBox(xyDelta: any): void;
    onSectionMouseDown(): void;
    hideUpdated(): void;
    constructObjectTreeFromNodeIds(nodeIds: any, options?: {}): {
        nodeIds: number[];
        ancestors: number[];
        children: number[];
    };
    clearFilteredObjectTree(params?: {}): void;
    getObjectTree(resourceId?: any, objectTreeName?: string): ObjectTree | undefined;
    syncObjectTreesWithHidden(params: any): void;
    syncObjectTreesWithSelected({ resourceId, sourceObjectTreeName, destinationObjectTreeName, }: {
        resourceId: any;
        sourceObjectTreeName: any;
        destinationObjectTreeName: any;
    }): void;
    validateObjectTree(resourceId: any, objectTreeName: any): boolean;
    isPartitionedModel(): boolean;
    setPwfFileCacheState(states: any): void;
    getPwfFileCacheState(): {
        meshnodeABCached: boolean;
        nodeABCached: boolean;
        meshABCached: boolean;
    };
    getPwfPartitionContentUrls(params?: {}): string[];
    getNumMeshes(params?: {}): number;
    getNumMeshnodes(params?: {}): number;
    getNumNodes(params?: {}): number;
    getMeasureObjectMeshesPartition(): Promise<import("../pwfreader/PWFTypes").MeshnodeObject[]>;
}
export namespace RenderController {
    namespace NullSelectedSubtree {
        let objectId: number;
        let selectionContainerId: number;
        let ancestry: never[];
    }
    function createCameras(options: any): {
        default: import("three").PerspectiveCamera;
        global: import("three").PerspectiveCamera;
        old: {
            position: import("three").Vector3;
            rotation: import("three").Vector3;
        };
    };
    function createScenes(options: any, cameras: any): {
        default: import("three").Scene;
    };
    function createLighting(cameras: any, scenes: any): {
        default: import("three").DirectionalLight;
        ambient: import("three").AmbientLight;
    };
    function createTextures(renderer: any): {
        picking: import("three").WebGLRenderTarget;
    };
    function sanitizeOptions(options: any): any;
}
import { StatusTrackingController } from './StatusTrackingController';
import { SectionController } from '../sectioning';
import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
import { ProcoreRenderPass } from '../procoregl/ProcoreRenderPass';
import { SectionRenderPass } from '../procoregl/SectionDisplay';
import { PickingController } from '../picking/PickingController';
import { PointToPointController } from '../measuring';
import { NavigationModel } from '../navigation/NavigationModel';
import { Models } from '../procoregl/Models';
import { ShortestDistanceController } from './ShortestDistanceController';
import { ColorServices } from '../procoregl/ColorServices';
import { ObjectTree } from '../procoregl/ObjectTree';
