Interface IVoxel3D

interface IVoxel3D {
    state: ViewerState;
    isReady: boolean;
    isDisposed: boolean;
    renderer: WebGLRenderer | null;
    scene: Scene<Object3DEventMap> | null;
    camera: PerspectiveCamera | OrthographicCamera | null;
    container: HTMLElement | null;
    events: EventSystem<Voxel3DEvents>;
    errors: ErrorSystem;
    width: number;
    height: number;
    start(): void;
    stop(): void;
    render(): void;
    resize(width?: number, height?: number): void;
    setBackgroundColor(color: ColorRepresentation): void;
    getBackgroundColor(): Color | null;
    setGridSize(size: number): void;
    setAxesSize(size: number): void;
    setGridVisible(visible: boolean): void;
    setAxesVisible(visible: boolean): void;
    getSceneSettings(): SceneSettings;
    setSceneSettings(settings: Partial<SceneSettings>): void;
    applySceneTheme(theme: SceneTheme): void;
    setFOV(fov: number): void;
    upAxis: UpAxis;
    setUpAxis(axis: UpAxis): void;
    flipUpVector(): void;
    getProjectionMode(): ProjectionMode;
    setProjectionMode(mode: ProjectionMode): void;
    getNavigationMode(): NavigationMode;
    setNavigationMode(mode: NavigationMode): void;
    getMouseControlMode(): MouseControlMode;
    setMouseControlMode(mode: MouseControlMode): void;
    setView(view: StandardView, animate?: boolean): void;
    setUpVector(dir: UpVectorDir, animate?: boolean): void;
    fitToBounds(offset?: number): void;
    focusOnObject(object: Object3D, offset?: number): void;
    focusOnSelected(offset?: number): void;
    setAutoRotate(enabled: boolean): void;
    setAutoRotateSpeed(speed: number): void;
    setDampingFactor(factor: number): void;
    fixedUpVector: boolean;
    setFixedUpVector(fixed: boolean): void;
    getCanvas(): HTMLCanvasElement | null;
    takeScreenshot(type?: string, quality?: number): string | null;
    computeBVH(
        object: Object3D,
        filter?: (mesh: Mesh) => boolean,
    ): BVHStats | null;
    computeBVHAsync(
        object: Object3D,
        options?: {
            onProgress?: (progress: number) => void;
            filter?: (mesh: Mesh) => boolean;
        },
    ): Promise<BVHStats | null>;
    disposeBVH(object: Object3D): void;
    setBVHHelperVisible(visible: boolean): void;
    setBVHOptions(options: Partial<BVHOptions>): void;
    getBVHStats(): BVHStats | null;
    setSelectionEnabled(enabled: boolean): void;
    selectedObject: Object3D<Object3DEventMap> | null;
    deselect(): void;
    highlightObject(object: Object3D): void;
    unhighlightAll(): void;
    outlineEnabled: boolean;
    setOutlineEnabled(enabled: boolean): void;
    setOutlineColor(color: ColorRepresentation): void;
    setOutlineThickness(thickness: number): void;
    setOutlineStrength(strength: number): void;
    setOutlineGlow(glow: number): void;
    setHiddenEdgeColor(color: ColorRepresentation): void;
    setOutlinePulsePeriod(period: number): void;
    setFXAAEnabled(enabled: boolean): void;
    setAllLight(): void;
    clearAdditionalLights(): void;
    setRoomEnvironment(): void;
    loadHDR(url: string): Promise<void>;
    clearEnvironment(): void;
    setEnvironmentBackgroundVisible(visible: boolean): void;
    setEnvironmentIntensity(intensity: number): void;
    setBackgroundBlurriness(blurriness: number): void;
    setBackgroundIntensity(intensity: number): void;
    setMeasureMode(mode: MeasureMode): void;
    startMeasure(): void;
    cancelMeasure(): void;
    clearAllMeasures(): void;
    deleteMeasure(id: string): void;
    getMeasurements(): MeasurementData[];
    onMeasureComplete(callback: (data: MeasurementData) => void): void;
    exportMeasurements(): MeasurementExport;
    initMeshAnalysis(force?: boolean): Promise<void>;
    registerAnimationClips(object: Object3D, clips: AnimationClip[]): void;
    unregisterAnimationClips(object: Object3D): void;
    getAnimationClips(objectUuid?: string): AnimationClipInfo[];
    getAnimatedModels(): AnimatedModelInfo[];
    playAnimation(clipName?: string, objectUuid?: string): void;
    pauseAnimation(): void;
    stopAnimation(): void;
    seekAnimation(time: number): void;
    setAnimationSpeed(speed: number): void;
    setAnimationLoopMode(mode: AnimationLoopMode): void;
    setAnimationForceVisible(enabled: boolean): void;
    crossfadeAnimation(clipName: string, duration?: number): void;
    getAnimationState(): AnimationState | null;
    loadPLMXML(file: File): Promise<void>;
    playPLMXML(): void;
    pausePLMXML(): void;
    stopPLMXML(): void;
    seekPLMXMLToFrame(frame: number): void;
    seekPLMXMLToTime(time: number): void;
    setPLMXMLPlaybackSpeed(speed: number): void;
    setPLMXMLLoop(loop: boolean): void;
    switchPLMXMLSequence(index: number): void;
    getPLMXMLAnimationState(): PLMXMLAnimationState | null;
    getPLMXMLCurrentTransforms(): Map<string, InterpolatedTransform>;
    isPLMXMLPlaying(): boolean;
    getPLMXMLTotalDuration(): number;
    bindPLMXMLObjects(
        coordinateConversion?: "none" | "z-up-to-y-up" | "y-up",
        autoApply?: boolean,
    ): void;
    setAutoApplyPLMXMLTransforms(enabled: boolean): void;
    applyCurrentPLMXMLTransforms(): void;
    resetPLMXMLObjects(): void;
    unbindPLMXMLObjects(): void;
    createClippingPlane(axis: ClippingAxis): string;
    deleteClippingPlane(planeId: string): void;
    deleteAllClippingPlanes(): void;
    setClippingEnabled(enabled: boolean): void;
    isClippingEnabled(): boolean;
    setClippingMode(side: ClipSide): void;
    getClippingMode(): ClipSide;
    setClippingPlaneSide(planeId: string, side: ClipSide): void;
    getClippingPlaneSide(planeId: string): ClipSide | null;
    setClippingPlanePositionPercent(planeId: string, percent: number): void;
    getClippingPlanePositionPercent(planeId: string): number | null;
    setPlaneConstant(planeId: string, constant: number): void;
    setPlaneStep(planeId: string, step: number): void;
    setClippingPlaneFromFace(
        planeId: string,
        worldNormal: Vector3,
        worldPoint: Vector3,
    ): void;
    enterClippingAlignMode(planeId: string): void;
    exitClippingAlignMode(): void;
    getClippingAlignModePlaneId(): string | null;
    setClippingEdgeVisible(visible: boolean): void;
    setClippingEdgeColor(color: ColorRepresentation): void;
    setClippingEdgeLineWidth(width: number): void;
    isClippingEdgeVisible(): boolean;
    getClippingEdgeColor(): number;
    getClippingEdgeLineWidth(): number;
    setClippingEdgePreview(enabled: boolean): void;
    getClippingEdgePreview(): boolean;
    setClippingPreciseEdge(enabled: boolean): void;
    getClippingPreciseEdge(): boolean;
    setClippingTargetMesh(
        mesh:
            | Mesh<
                BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>,
                Material<MaterialEventMap> | Material<MaterialEventMap>[],
                Object3DEventMap,
            >
            | null,
    ): void;
    setClippingTargetMeshes(
        meshes:
            | Mesh<
                BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>,
                Material<MaterialEventMap> | Material<MaterialEventMap>[],
                Object3DEventMap,
            >[]
            | null,
    ): void;
    setClippingScope(nodeIds: string[] | null): void;
    getClippingTargetMesh(): | Mesh<
        BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>,
        Material<MaterialEventMap> | Material<MaterialEventMap>[],
        Object3DEventMap,
    >
    | null;
    setClippingGizmoVisible(visible: boolean): void;
    isClippingGizmoVisible(): boolean;
    setClippingBoundsVisible(visible: boolean): void;
    isClippingBoundsVisible(): boolean;
    setAllClippingUIVisible(visible: boolean): void;
    selectClippingGizmo(planeId: string): void;
    deselectClippingGizmo(): void;
    setClippingGizmoMode(mode: GizmoTransformMode): void;
    getClippingPlanes(): ClippingPlaneData[];
    createSectionBox(): void;
    setClippingSectionBox(min: Vector3, max: Vector3): void;
    setClippingSectionBoxEnabled(enabled: boolean): void;
    setClippingSectionBoxFace(face: SectionBoxFace, value: number): void;
    deleteClippingSectionBox(): void;
    getClippingSectionBox(): SectionBoxData | null;
    createClippingSlab(axisOrNormal: ClippingAxis | Vector3): void;
    setClippingSlabPosition(center: number): void;
    stepClippingSlab(delta: number): void;
    setClippingSlabThickness(thickness: number): void;
    setClippingSlabEnabled(enabled: boolean): void;
    deleteClippingSlab(): void;
    getClippingSlab(): SlabData | null;
    getClippingSnapshot(): ClippingSnapshot | null;
    restoreClippingSnapshot(snapshot: ClippingSnapshot): void;
    on<K extends keyof Voxel3DEvents>(
        event: K,
        callback: (data: Voxel3DEvents[K]) => void,
    ): () => void;
    sceneGraph: ISceneGraphManager;
    registerModel(rootObject: Object3D, modelName: string): string;
    registerSceneNode(options: RegisterNodeOptions): string;
    deleteSceneNode(nodeId: string): void;
    setSceneNodeVisible(nodeId: string, visible: boolean): void;
    logSceneGraph(): void;
    importJsonTree(
        jsonOrUrl: string | JsonTreeNode,
        basePath: string,
    ): Promise<string>;
    loadCheckedModels(): Promise<void>;
    hasFolder: boolean;
    folderName: string | null;
    pickFolder(): Promise<boolean>;
    loadFiles(files: FileList): Promise<ImportResult[]>;
    loadUrl(url: string): Promise<ImportResult>;
    loadNodeById(nodeId: string): Promise<void>;
    clearImportResources(): void;
    getMissingTextures(): MissingTextureEntry[];
    resolveMissingTextures(
        files: FileList | File[],
    ): Promise<MissingTextureResolveResult>;
    clearMissingTextures(): void;
    clearModelCache(): Promise<boolean>;
    getModelCacheStats(): ModelCacheStats | null;
    setImportFileOverlap(enabled: boolean): void;
    getImportFileOverlap(): boolean;
    setImportBinCacheInject(enabled: boolean): void;
    getImportBinCacheInject(): boolean;
    setImportWorkerParse(enabled: boolean): void;
    getImportWorkerParse(): boolean;
    setImportWorkerParseVerify(enabled: boolean): void;
    getImportWorkerParseVerify(): boolean;
    setImportWorkerLoadPoC(enabled: boolean): void;
    getImportWorkerLoadPoC(): boolean;
    setImportRenderSuppression(enabled: boolean): void;
    getImportRenderSuppression(): boolean;
    getSceneAddMode(): SceneAddMode;
    setSceneAddMode(mode: SceneAddMode): void;
    batchRenderingEnabled: boolean;
    enableBatchRendering(batchSize?: number): void;
    disableBatchRendering(): void;
    flushBatchRender(): void;
    getBatchRenderStats(): | {
        queueSize: number;
        totalRendered: number;
        totalBatches: number;
    }
    | null;
    isBatchedRenderingEnabled(): boolean;
    setBatchedRendering(enabled: boolean): void;
    transformEnabled: boolean;
    enableTransform(): void;
    disableTransform(): void;
    resetTransform(): void;
    setTransformSpace(space: TransformSpace): void;
    setTransformTarget(object: Object3D<Object3DEventMap> | null): void;
    undoTransform(): void;
    redoTransform(): void;
    setTransformSnap(
        snap: {
            translation?: number | null;
            rotation?: number | null;
            scale?: number | null;
        },
    ): void;
    setTransformGizmoVisible(visible: boolean): void;
    isTransformGizmoVisible(): boolean;
    selectMaterialTarget(mesh: Mesh): void;
    deselectMaterialTarget(): void;
    setMaterialColor(color: Color): void;
    setMaterialRoughness(roughness: number, recordHistory?: boolean): void;
    setMaterialMetalness(metalness: number, recordHistory?: boolean): void;
    setMaterialEnvMapIntensity(
        intensity: number,
        recordHistory?: boolean,
    ): void;
    adjustMaterialHSL(
        adjustments: { hue?: number; saturation?: number; brightness?: number },
        recordHistory?: boolean,
    ): void;
    resetMaterial(): void;
    undoMaterial(): boolean;
    redoMaterial(): boolean;
    selectTextureTarget(mesh: Mesh): void;
    deselectTextureTarget(): void;
    loadTextureFromFile(
        slot: TextureSlot,
        file: File,
    ): Promise<TextureInfo | null>;
    loadTextureFromUrl(
        slot: TextureSlot,
        url: string,
    ): Promise<TextureInfo | null>;
    removeTexture(slot: TextureSlot): void;
    setTextureUVSettings(
        slot: TextureSlot,
        settings: Partial<TextureUVSettings>,
    ): void;
    resetTextureUVSettings(slot: TextureSlot): void;
    setTextureFilterSettings(
        slot: TextureSlot,
        settings: Partial<TextureFilterSettings>,
    ): void;
    getTextureInfo(slot: TextureSlot): TextureInfo | null;
    availableTextureSlots: TextureSlotInfo[];
    currentTextureState: TextureState | null;
    setViewCubeVisible(visible: boolean): void;
    setViewCubeEnabled(enabled: boolean): void;
    setViewCubeCorner(corner: ViewCubeCorner): void;
    setViewCubeSize(size: number): void;
    setViewCubeFaceLabels(labels: Partial<ViewCubeFaceLabels>): void;
    setViewCubeOffset(offsetX: number, offsetY: number): void;
    setViewCubeColors(colors: ViewCubeColorOptions): void;
    setMarkupEnabled(enabled: boolean): void;
    isMarkupEnabled(): boolean;
    enterMarkupAddMode(type: MarkupType): void;
    exitMarkupAddMode(): void;
    getMarkupAddMode(): MarkupAddMode;
    selectMarkup(markupId: string): void;
    deselectMarkup(): void;
    selectedMarkup: { id: string; type: MarkupType } | null;
    deleteMarkup(markupId: string): boolean;
    deleteAllMarkups(): void;
    getMarkupList(type?: MarkupType): MarkupListItem[];
    getMarkupData(markupId: string): MarkupData | null;
    markupCount: number;
    subscribeToLogs(handler: LogHandler): () => void;
    getLogHistory(filter?: LogHistoryFilter): LogEntry[];
    setAnalyticsHandler(handler: AnalyticsHandler | null): void;
    createSnapshot(name: string, description?: string): SnapshotData;
    applySnapshot(id: string): boolean;
    deleteSnapshot(id: string): boolean;
    updateSnapshot(
        id: string,
        updates: { name?: string; description?: string },
    ): boolean;
    getSnapshots(): readonly SnapshotData[];
    getCurrentSnapshotId(): string | null;
    exportSnapshotSession(): SnapshotSessionData;
    importSnapshotSession(data: SnapshotSessionData): boolean;
    clearSnapshotSession(): void;
    getPerformanceReport(): PerformanceReport;
    printPerformanceReport(): void;
    getImportReport(): ImportReport | null;
    getImportPerformanceReport(): ImportPerformanceReport | null;
    printImportReport(): string;
    printImportProfile(): string;
    benchRender(durationSec?: number): Promise<string>;
    dispose(): void;
}