import { Box3, Group, Material, Matrix4, Object3D, Scene, Vector3 } from 'three';
import { SceneEvents } from './SceneEvents';
import { SceneTools } from './SceneTools';
import { ClippingTools } from '../render/ClippingTools';
import { ElementData } from './ElementData';
import { SceneShadow } from './SceneShadow';
import { SceneModel } from './SceneModel';
import { SceneWorkerLoadedMessage } from './SceneWorkerMessage';
import { InstanceGeometry } from './InstanceGeometry';
import { SceneCallbacks } from './SceneCallbacks';
import { SharedGeometry } from './SharedGeometry';
import TraverseCallbackOptions = SceneCallbacks.TraverseCallbackOptions;
/**
 * Loads models (geometric data) from buckets and provides functions to manage elements from these models (selection, traversing and so on).
 * @example
 * const sceneManager = new SceneManager()
 *    .onProgress((progress:number)=>{
 *       console.log('Loading progress: '+ progress +'%')
 *    })
 *    .onLoaded((modelId: string)=>{
 *       console.log('Model: '+ modelId +' is loaded')
 *    })
 *    .onAllLoaded(()=>{
 *       console.log('All models are loaded')
 *    })
 *    .load("<GEOMETRY_GUID>")
 */
export declare class SceneManager extends EventTarget {
    readonly tag = "SceneManager";
    /**Tools class for elements management. */
    tools: SceneTools;
    /**Tools class for operations with clipping planes. */
    clippingTools: ClippingTools;
    /**Main scene for general geometry objects.*/
    scene: Scene;
    /**Loaded models info.*/
    models: Map<string, SceneModel>;
    /**Lines scene group.*/
    groupLights: Group<import('three').Object3DEventMap>;
    /**General elements (meshes and lines and phantoms) scene group.*/
    groupElements: Group<import('three').Object3DEventMap>;
    /**Meshes scene group.*/
    groupMeshes: Group<import('three').Object3DEventMap>;
    /**Not transparent meshes scene group.*/
    groupOpaque: Group<import('three').Object3DEventMap>;
    /**Transparent meshes scene group.*/
    groupTrans: Group<import('three').Object3DEventMap>;
    /**Line meshes scene group.*/
    groupLines: Group<import('three').Object3DEventMap>;
    /**Phantom meshes scene group.*/
    groupPhantoms: Group<import('three').Object3DEventMap>;
    /**Element`s edges scene group.*/
    groupEdges: Group<import('three').Object3DEventMap>;
    /**Materials catalog for loaded models.*/
    materials: Map<string, Material>;
    /** Material for element edges. **/
    edgesMaterial: Material;
    /**Map for original indices of all geometry objects. Used to restore elements visibility. */
    originalIndices: Map<string, Uint32Array<ArrayBufferLike>>;
    /**Map for original matrices for instance objects. Could be used to restore elements visibility. */
    originalMatrices: Map<string, Matrix4[]>;
    /**Additional elements data like bounding box.*/
    elementDatas: Map<number, ElementData>;
    /**Scene temporary bounding box.*/
    selBox: Box3;
    /**Scene bounding box.*/
    sceneBox: Box3;
    /**Is progressive render mode on.*/
    isProgressive: boolean;
    /**Geometry numbers for selected elements.*/
    selElNums: number[];
    /**Is navigation process has been started by active controller extension. */
    isNavigationStarted: boolean;
    /** Load progress when models are loading. */
    loadProgress: number;
    /** Are models loading. */
    loadProgressShow: boolean;
    /** Inner scene origin. */
    private origin;
    /** Is any geometry data loaded. */
    isNoData: boolean;
    /**Total elements hided by degradation system in navigation process. */
    totalDegradedChilds: number;
    /** Maximum number of models that will be saved to the browser cache for faster later opening. */
    maxModelsCache: number;
    /**
     * Determines whether to use the WebAssembly (WASM) implementation of LZMA.
     *
     * When true, the system will use the optimized lzma-wasm library for decompression.
     * When false, it will fall back to the default JavaScript implementation WLZMAWeb.
     *
     * @default false
     */
    useWasmLzma: boolean;
    sceneShadow: SceneShadow;
    private globalOrigin;
    protected isDisposed: boolean;
    deltaMed: number;
    deltaMed2: number;
    deltaCounter: number;
    private maxDegradeSharedLength;
    private maxDegradeInstancesLength;
    private server;
    private serverPath;
    private progressCallback;
    private loadedCallback;
    private notFoundCallback;
    private errorCallback;
    private allLoadedCallback;
    private token;
    private geomWorker;
    /** Show fog effect or not. */
    showFog: boolean;
    /** Show earth shadow effect or not. */
    showGroundShadow: boolean;
    /**
     * Set acces token for manager`s requests.
     * @param token - access token.
     */
    setToken(token: string): SceneManager;
    constructor();
    /**
     * Get scene global origin coordinates.
     */
    getGlobalOrigin(): Vector3;
    /**
     * Get all children elements and meshes from all scenes.
     * @param getOpaqueChildren - should function add children from opaque group.
     * @param getTransparentChildren - should function add children from transparent scene (transparent meshes).
     * @param getLineChildren - should function add children from line scene (lines).
     */
    getSceneChldren(getOpaqueChildren?: boolean, getTransparentChildren?: boolean, getLineChildren?: boolean): Array<Object3D>;
    /**
     * Set a callback for an model loading progress event.
     * @group Callbacks
     * @param progressCallback - function with ProgressCallbackFunction signature.
     */
    onProgress(progressCallback: SceneCallbacks.ProgressCallbackFunction): SceneManager;
    /**
     * Set a callback for an event when each model will be loaded.
     * @group Callbacks
     * @param loadedCallback - function with LoadedCallbackFunction signature.
     */
    onLoaded(loadedCallback: SceneCallbacks.LoadedCallbackFunction): SceneManager;
    /**
     * Set a callback for an event when some model will not be founded.
     * @group Callbacks
     * @param notFoundCallback - function with NotFoundCallbackFunction signature.
     */
    onNotFound(notFoundCallback: SceneCallbacks.NotFoundCallbackFunction): SceneManager;
    /**
     * Set a callback for an event when a model will not be loaded due to an error.
     * @group Callbacks
     * @param errorCallback - function with ErrorCallbackFunction signature.
     */
    onError(errorCallback: SceneCallbacks.ErrorCallbackFunction): SceneManager;
    /**
     * Set callback function for event when all models will be loaded.
     * @group Callbacks
     * @param allLoadedCallback - function with plain Function signature.
     */
    onAllLoaded(allLoadedCallback: Function): SceneManager;
    /**
     * Set server path to RESt point for data loading.
     * @param path - path to server REST point.
     */
    setServerPath(path?: string): SceneManager;
    /**
     * Set server URI for data loading.
     * @param server - server URI.
     */
    setServer(server?: string): SceneManager;
    getOrCreateMaterial(gData: SharedGeometry): Material;
    createSharedMeshGeometry(sharedGeoms: Map<string, SharedGeometry>, generateBvhOnLoad: boolean, generateEdges: boolean, geomNumber: number): void;
    createMultiMeshGeometry(sharedGeoms: Map<string, SharedGeometry>): void;
    createInstancedMeshGeometry(instanceGeoms: Map<any, InstanceGeometry>, generateEdges: boolean, geomNumber: number): void;
    addModelData(data: SceneWorkerLoadedMessage, generateEdges?: boolean, generateBvhOnLoad?: boolean): void;
    private createInstancedLodsMesh;
    /**
     * Unload models geometry from scene.
     * @param ids - Model version GUID or model version GUIDs with comma separator or GUIDs array.
     */
    unload(ids: string | string[]): void;
    /**
     * Calculate whole scene bounding box.
     */
    calculateSceneBox(): void;
    /**
     * Load models into scene.
     * @param ids - Model version GUID or model version GUIDs with comma separator or GUIDs array.
     * @param crossOriginWorkerMode - Mode for SceneWorker loading. Use this flag if you are experiencing problems loading the worker due to CORS or Origin policies.
     */
    load(ids: string | string[], crossOriginWorkerMode?: boolean, isShared?: boolean, vIds?: string[]): void;
    private checkAllLoaded;
    /**
     * Process scene degradation when progressive render mode is on.
     * @param force - force manual degradation.
     */
    degradeScene(force?: boolean): void;
    /**
     * Reset scene degradation when progressive render mode is active.
     */
    undegradeScene(): void;
    /**
     * Select one or many elements in scene.
     * @param elNums - Elements numbers for selection.
     * @param forceAdd - Add new selection to current or replace.
     * @param forceEvent - Force SceneEvents.Selected event dispatching.
     * @param source - Source object which call updateSelection(). Will be pass in "selected" event.
     */
    updateSelection(elNums?: number[], forceAdd?: boolean, forceEvent?: boolean, source?: any): void;
    /**
     * Gather sub-elements for given element numbers.
     * @param elNums - Elements numbers.
     */
    gatherSubElements(elNums: number[]): number[];
    /**
     * Get bounding box for given element numbers.
     * @param elNums - Elements numbers.
     */
    getBoundings(elNums: number[]): Box3;
    /**
     * Scan and gather scene geometry buffers and return buffer data only for elements list associated with custom values array.
     * Used for changing buffers data for particular elements in model.
     * @param elNums - Elements numbers for for gathering.
     * @param elVals - Elements values for gathering.
     * @param callbacks - See {@link SceneCallbacks.TraverseCallbackOptions}
     */
    traverseElementsWithValues(elNums: number[], elVals: any[] | any, callbacks: TraverseCallbackOptions): void;
    /**
     * Scan and gather scene geometry buffers and return buffer data only for elements list.
     * Used for changing buffers data for particular elements in model.
     * @param elNums - Elements numbers for for gathering.
     * @param callbacks - See {@link SceneCallbacks.TraverseCallbackOptions}
     */
    traverseElements(elNums: number[], callbacks: TraverseCallbackOptions): void;
    /**
     * Scan and gather scene geometry buffers and return buffer data for all elements.
     * Used for changing buffers data for particular elements in model.
     * @param callbacks - See {@link SceneCallbacks.TraverseCallbackOptions}
     */
    traverseAllElements(callbacks: TraverseCallbackOptions): void;
    private initEdgesMaterial;
    /**
     * Clear scene assets.
     */
    clear(): void;
    /**
     * Add event listener with automatic dispose.
     * @param eventType - event type.
     * @param eventListener - event listener.
     * @param signal - optional abort signal for manual aborting event listener.
     */
    addAutoEventListener(eventType: SceneEvents, eventListener: EventListenerOrEventListenerObject, signal: AbortSignal): void;
    /**
     * Destroy scene assets and dispose resources.
     */
    destroy(): void;
    onResize(width: number, height: number, pixelRatio: number): void;
    setSketchMode(enabled: boolean): void;
}