import * as THREE from "three";
import { type IManager } from "@shapediver/viewer.rendering-engine.rendering-engine";
import { type IBox } from "@shapediver/viewer.shared.math";
import { type ITreeNode, type ITreeNodeData } from "@shapediver/viewer.shared.node-tree";
import { RENDERER_TYPE } from "@shapediver/viewer.shared.types";
import { SDObject } from "../objects/SDObject";
import { RenderingEngine } from "../RenderingEngine";
export declare class SceneTreeManager implements IManager {
    private readonly _renderingEngine;
    private readonly _eventEngine;
    private readonly _performanceEvaluator;
    private readonly _scene;
    private readonly _stateEngine;
    private readonly _tree;
    private _boundingBox;
    private _currentSDTFOverview;
    private _directionalLightData;
    private _hiddenCamera;
    private _lastRendererType;
    private _lastRootVersion;
    private _mainConvertedObject;
    private _newRendererType;
    private _suspendSceneUpdates;
    constructor(_renderingEngine: RenderingEngine);
    get boundingBox(): IBox;
    get lastRendererType(): RENDERER_TYPE;
    get lastRootVersion(): string;
    get mainNode(): SDObject;
    get scene(): THREE.Scene;
    get suspendSceneUpdates(): boolean;
    set suspendSceneUpdates(value: boolean);
    init(): void;
    /**
     * Convert the data of the scene graph node into the format of the implementation.
     *
     * @param data the data element
     * @param obj the corresponding type node
     */
    updateData(treeNodeData: ITreeNodeData, treeNode: ITreeNode, convertedObject: SDObject, filter?: UpdateFilter, isVisibleInHierarchy?: boolean): void;
    /**
     * Update the current node via the scene graph node.
     * Convert the data if needed.
     *
     * @param treeNode the scene graph node
     * @param obj the current type object
     */
    updateNode(treeNode?: ITreeNode, obj?: THREE.Object3D, filter?: UpdateFilter, visibleInHierarchy?: boolean): void;
    updateSceneTree(rootTreeNode: ITreeNode): void;
    /**
     * Remove obsolete child nodes from the converted object
     */
    private cleanupObsoleteChildren;
    /**
     * Remove obsolete data items from the converted object
     */
    private cleanupObsoleteData;
    /**
     * Check if a node is visible in the current viewport
     */
    private isNodeVisible;
    /**
     * Process a child node by creating it if needed, updating it, and syncing bounding boxes
     */
    private processChildTreeNode;
    /**
     * Reset and initialize bounding boxes for a node
     */
    private resetBoundingBoxes;
    /**
     * Resolves the converted object for a node, handling cases where it doesn't exist
     */
    private resolveConvertedObject;
    /**
     * Union child bounding boxes with parent bounding boxes
     */
    private unionChildBoundingBoxes;
}
type UpdateFilter = {
    transformationOnly: boolean;
};
export {};
//# sourceMappingURL=SceneTreeManager.d.ts.map