/**
 * @module vim-loader
 */
import * as THREE from 'three';
import { VimDocument, G3d, VimHeader, FilterMode } from 'vim-format';
import { Scene } from './scene';
import { VimSettings } from './vimSettings';
import { Object3D } from './object3D';
import { ElementMapping, ElementMapping2, ElementNoMapping } from './elementMapping';
import { ISignal } from 'ste-signals';
import { G3dSubset } from './progressive/g3dSubset';
import { SubsetBuilder } from './progressive/subsetBuilder';
import { LoadPartialSettings } from './progressive/subsetRequest';
type VimFormat = 'vim' | 'vimx';
/**
 * Represents a container for the built three.js meshes and the vim data from which they were constructed.
 * Facilitates high-level scene manipulation by providing access to objects.
 */
export declare class Vim {
    /**
     * Indicates whether the vim was opened from a vim or vimx file.
     */
    readonly format: VimFormat;
    /**
     * Indicates the url this vim came from if applicable.
     */
    readonly source: string | undefined;
    /**
     * The header for this vim.
     */
    readonly header: VimHeader | undefined;
    /**
     * The interface to access bim data related to this vim if available.
     */
    readonly bim: VimDocument | undefined;
    /**
     * The raw g3d geometry scene definition.
     */
    readonly g3d: G3d | undefined;
    /**
     * The settings used when this vim was opened.
     */
    readonly settings: VimSettings;
    /**
     * Mostly Internal - The scene in which the vim geometry is added.
     */
    readonly scene: Scene;
    /**
     * The mapping from Bim to Geometry for this vim.
     */
    readonly map: ElementMapping | ElementNoMapping | ElementMapping2;
    private readonly _builder;
    private readonly _loadedInstances;
    private readonly _elementToObject;
    /**
     * Getter for accessing the event dispatched whenever a subset begins or finishes loading.
     * @returns {ISignal} The event dispatcher for loading updates.
     */
    get onLoadingUpdate(): ISignal;
    /**
     * Indicates whether there are subsets currently being loaded.
     * @returns {boolean} True if subsets are being loaded; otherwise, false.
     */
    get isLoading(): boolean;
    /**
     * Getter for accessing the signal dispatched when the object is disposed.
     * @returns {ISignal} The signal for disposal events.
     */
    get onDispose(): ISignal;
    private _onDispose;
    /**
   * Constructs a new instance of a Vim object with the provided parameters.
   * @param {VimHeader | undefined} header - The Vim header, if available.
   * @param {VimDocument} document - The Vim document.
   * @param {G3d | undefined} g3d - The G3d object, if available.
   * @param {Scene} scene - The scene containing the vim's geometry.
   * @param {VimSettings} settings - The settings used to open this vim.
   * @param {ElementMapping | ElementNoMapping | ElementMapping2} map - The element mapping.
   * @param {SubsetBuilder} builder - The subset builder for constructing subsets of the Vim object.
   * @param {string} source - The source of the Vim object.
   * @param {VimFormat} format - The format of the Vim object.
   * @param {boolean} isLegacy - Indicates whether the Vim object uses a legacy loading pipeline.
   */
    constructor(header: VimHeader | undefined, document: VimDocument, g3d: G3d | undefined, scene: Scene, settings: VimSettings, map: ElementMapping | ElementNoMapping | ElementMapping2, builder: SubsetBuilder, source: string, format: VimFormat);
    /**
     * Retrieves the matrix representation of the Vim object's position, rotation, and scale.
     * @returns {THREE.Matrix4} The matrix representing the Vim object's transformation.
     */
    getMatrix(): THREE.Matrix4;
    /**
     * Retrieves the object associated with the specified instance number.
     * @param {number} instance - The instance number of the object.
     * @returns {THREE.Object3D | undefined} The object corresponding to the instance, or undefined if not found.
     */
    getObjectFromInstance(instance: number): Object3D;
    /**
     * Retrieves the objects associated with the specified element ID.
     * @param {number} id - The element ID to retrieve objects for.
     * @returns {THREE.Object3D[]} An array of objects corresponding to the element ID, or an empty array if none are found.
     */
    getObjectsFromElementId(id: number): any;
    /**
     * Retrieves the Vim object associated with the given Vim element index.
     * @param {number} element - The index of the Vim element.
     * @returns {Object3D | undefined} The Vim object corresponding to the element index, or undefined if not found.
     */
    getObjectFromElement(element: number): Object3D | undefined;
    /**
     * Retrieves an array containing all Vim objects strictly contained within the specified bounding box.
     * @param {THREE.Box3} box - The bounding box to search within.
     * @returns {Object3D[]} An array of Vim objects strictly contained within the bounding box.
     */
    getObjectsInBox(box: THREE.Box3): Object3D[];
    /**
     * Retrieves an array of all objects within the Vim.
     * @returns {Object3D[]} An array containing all objects within the Vim.
     */
    getObjects(): Object3D[];
    /**
     * Retrieves an array containing all objects within the specified subset.
     * @param {G3dSubset} subset - The subset to retrieve objects from.
     * @returns {Object3D[]} An array of objects within the specified subset.
     */
    getObjectsInSubset(subset: G3dSubset): Object3D[];
    /**
     * Retrieves all instances as a subset.
     * @returns {G3dSubset} A subset containing all instances.
     */
    getFullSet(): G3dSubset;
    /**
     * Asynchronously loads all geometry according to the provided settings.
     * @param {LoadPartialSettings} [settings] - Optional settings for the loading process.
     */
    loadAll(settings?: LoadPartialSettings): Promise<void>;
    /**
     * Asynchronously loads geometry for the specified subset according to the provided settings.
     * @param {G3dSubset} subset - The subset to load resources for.
     * @param {LoadPartialSettings} [settings] - Optional settings for the loading process.
     */
    loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): Promise<void>;
    /**
     * Asynchronously loads geometry based on a specified filter mode and criteria.
     * @param {FilterMode} filterMode - The mode of filtering to apply.
     * @param {number[]} filter - The filter criteria.
     * @param {LoadPartialSettings} [settings] - Optional settings for the loading process.
     */
    loadFilter(filterMode: FilterMode, filter: number[], settings?: LoadPartialSettings): Promise<void>;
    /**
     * Removes the current geometry from the renderer.
     */
    clear(): void;
    /**
     * Cleans up and releases resources associated with the vim.
     */
    dispose(): void;
}
export {};
