@thatopen/components 2.0.0-alpha.10 → 2.0.0-alpha.12

package/dist/namespace.d.ts

@@ -1,980 +1,950 @@
 declare namespace OBC {
-import { Component, Disposable, Event } from "../Types";
-/**
- * The entry point of the Components library.
- * It can:
- * - Create and access all the components of the library.
- * - Update all the updatable components automatically.
- * - Dispose all the components, preventing memory leaks.
- */
-export declare class Components implements Disposable {
-    static readonly release = "1.4.21";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<void>;
-    /** The list of components created in this app. */
-    readonly list: Map<string, Component>;
-    /** If disabled, the animation loop will be stopped. */
-    enabled: boolean;
-    private _clock;
-    add(uuid: string, instance: Component): void;
-    /**
-     * Retrieves a component. If it already exists in this app, it returns the instance of the component. If it
-     * doesn't exist, it will instance it automatically.
-     *
-     * @param Component - The component to get or create.
-     */
-    get<U extends Component>(Component: new (components: Components) => U): U;
-    constructor();
-    /**
-     * Initializes the library. It should be called at the start of the app after
-     * initializing the scene, the renderer and the
-     * camera. Additionally, if any component that need a raycaster is
-     * used, the {@link raycaster} will need to be initialized.
-     */
-    init(): void;
-    /**
-     * Disposes the memory of all the components and tools of this instance of
-     * the library. A memory leak will be created if:
-     *
-     * - An instance of the library ends up out of scope and this function isn't
-     * called. This is especially relevant in Single Page Applications (React,
-     * Angular, Vue, etc).
-     *
-     * - Any of the objects of this instance (meshes, geometries, etc) is
-     * referenced by a reference type (object or array).
-     *
-     * You can learn more about how Three.js handles memory leaks
-     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
-     *
-     */
-    dispose(): void;
-    private update;
-    private static setupBVH;
-}
-import { Component, Disposable, World, Event } from "../Types";
-import { GridConfig, SimpleGrid } from "./src";
-export declare class Grids extends Component implements Disposable {
-    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
-    list: Map<string, SimpleGrid>;
-    onDisposed: Event<unknown>;
-    config: Required<GridConfig>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    create(world: World): void;
-    delete(world: World): void;
-    dispose(): void;
-}
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
-/**
- * A tool to safely remove meshes and geometries from memory to
- * [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
+export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
+import { Component, Disposable, Event, Components } from "../../core";
+export declare class FragmentExploder extends Component implements Disposable {
+    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
     enabled: boolean;
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * {@link Component.uuid}.
-     * @return the list of UUIDs of deleted components.
-     */
-    get(): Set<string>;
-    /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
-     *
-     * @param recursive - whether to recursively dispose the children of the mesh.
-     */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
-    /**
-     * Disposes a geometry from memory.
-     *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
-     */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}
-import * as THREE from "three";
-import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
-import { SimplePlane } from "./src";
-import { Components } from "../Components";
-/**
- * A lightweight component to easily create and handle
- * [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes).
- *
- * @param components - the instance of {@link Components} used.
- * @param planeType - the type of plane to be used by the clipper.
- * E.g. {@link SimplePlane}.
- */
-export declare class Clipper<T extends SimplePlane> extends Component implements Createable, Disposable, Hideable {
-    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
-    /** {@link Createable.onAfterCreate} */
-    readonly onAfterCreate: Event<T>;
-    /** {@link Createable.onAfterDelete} */
-    readonly onAfterDelete: Event<T>;
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onBeforeDrag: Event<void>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onAfterDrag: Event<void>;
-    readonly onBeforeCreate: Event<unknown>;
-    readonly onBeforeCancel: Event<unknown>;
-    readonly onAfterCancel: Event<unknown>;
-    readonly onBeforeDelete: Event<unknown>;
+    height: number;
+    groupName: string;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
-    /**
-     * Whether to force the clipping plane to be orthogonal in the Y direction
-     * (up). This is desirable when clipping a building horizontally and a
-     * clipping plane is created in its roof, which might have a slight
-     * slope for draining purposes.
-     */
-    orthogonalY: boolean;
-    /**
-     * The tolerance that determines whether an almost-horizontal clipping plane
-     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
-     * has to be 'true' for this to apply.
-     */
-    toleranceOrthogonalY: number;
-    list: T[];
-    protected PlaneType: new (...args: any) => SimplePlane | T;
-    /** The material used in all the clipping planes. */
-    protected _material: THREE.MeshBasicMaterial;
-    private _size;
-    private _enabled;
-    private _visible;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The material of the clipping plane representation. */
-    get material(): THREE.MeshBasicMaterial;
-    /** The material of the clipping plane representation. */
-    set material(material: THREE.MeshBasicMaterial);
-    /** The size of the geometric representation of the clippings planes. */
-    get size(): number;
-    /** The size of the geometric representation of the clippings planes. */
-    set size(size: number);
+    list: Set<string>;
     constructor(components: Components);
-    endCreation(): void;
-    cancelCreation(): void;
-    /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@link Createable.create} */
-    create(world: World): void;
-    /**
-     * Creates a plane in a certain place and with a certain orientation,
-     * without the need of the mouse.
-     *
-     * @param world - the world where this plane should be created.
-     * @param normal - the orientation of the clipping plane.
-     * @param point - the position of the clipping plane.
-     * navigation.
-     */
-    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): T;
-    /**
-     * {@link Createable.delete}
-     *
-     * @param world - the world where the plane to delete is.
-     * @param plane - the plane to delete. If undefined, the first plane
-     * found under the cursor will be deleted.
-     */
-    delete(world: World, plane?: T): void;
-    /** Deletes all the existing clipping planes. */
-    deleteAll(): void;
-    private deletePlane;
-    private pickPlane;
-    private getAllPlaneMeshes;
-    private createPlaneFromIntersection;
-    private getWorldNormal;
-    private normalizePlaneDirectionY;
-    private newPlane;
-    protected newPlaneInstance(world: World, point: THREE.Vector3, normal: THREE.Vector3): T;
-    private updateMaterialsAndPlanes;
-    private _onStartDragging;
-    private _onEndDragging;
+    explode(): void;
+    reset(): void;
+    update(): void;
 }
 import * as THREE from "three";
-import { Component, Disposable, Event } from "../Types";
-import { Components } from "../Components";
+import * as FRAGS from "@thatopen/fragments";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Components, Disposable, Event } from "../../core";
 /**
- * A tool to easily handle the materials of massive amounts of
- * objects and scene background easily.
+ * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but
+ * it's fast, and should suffice for general use cases such as camera zooming or general boundary determination.
  */
-export declare class Materials extends Component implements Disposable {
-    static readonly uuid: "24989d27-fa2f-4797-8b08-35918f74e502";
+export declare class BoundingBoxes extends Component implements Disposable {
+    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
     /** {@link Component.enabled} */
     enabled: boolean;
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    list: {
-        [id: string]: {
-            material: THREE.Material;
-            meshes: Set<THREE.Mesh | THREE.InstancedMesh>;
-        };
-    };
-    private _originals;
+    readonly onDisposed: Event<unknown>;
+    private _absoluteMin;
+    private _absoluteMax;
+    private _meshes;
     constructor(components: Components);
+    static getDimensions(bbox: THREE.Box3): {
+        width: number;
+        height: number;
+        depth: number;
+        center: THREE.Vector3;
+    };
+    static newBound(positive: boolean): THREE.Vector3;
+    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /**
-     * Turns the specified material styles on or off.
-     *
-     * @param active whether to turn it on or off.
-     * @param ids the ids of the style to turn on or off.
-     */
-    set(active: boolean, ids?: string[]): void;
-    /**
-     * Creates a new material style.
-     * @param id the identifier of the style to create.
-     * @param material the material of the style.
-     */
-    addMaterial(id: string, material: THREE.Material): void;
-    /**
-     * Assign meshes to a certain style.
-     * @param id the identifier of the style.
-     * @param meshes the meshes to assign to the style.
-     */
-    addMeshes(id: string, meshes: THREE.Mesh[]): void;
-    /**
-     * Remove meshes from a certain style.
-     * @param id the identifier of the style.
-     * @param meshes the meshes to assign to the style.
-     */
-    removeMeshes(id: string, meshes: THREE.Mesh[]): void;
+    get(): THREE.Box3;
+    getSphere(): THREE.Sphere;
+    getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    reset(): void;
+    add(group: FragmentsGroup): void;
+    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
+    private static getFragmentBounds;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
-import { Components } from "../Components";
-export declare class Raycasters extends Component implements Disposable {
-    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
+export declare class FragmentHider extends Component {
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
     enabled: boolean;
-    list: Map<string, SimpleRaycaster>;
-    onDisposed: Event<unknown>;
     constructor(components: Components);
-    get(world: World): SimpleRaycaster;
-    delete(world: World): void;
-    dispose(): void;
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
 }
-import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
-import { Components } from "../Components";
-import { SimpleWorld } from "./src";
-export declare class Worlds extends Component implements Updateable, Disposable {
-    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
-    readonly onAfterUpdate: Event<unknown>;
-    readonly onBeforeUpdate: Event<unknown>;
-    readonly onDisposed: Event<unknown>;
-    list: Map<string, World>;
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
+export declare class FragmentIfcLoader extends Component implements Disposable {
+    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    readonly onIfcStartedLoading: Event<void>;
+    readonly onSetup: Event<void>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    settings: IfcFragmentSettings;
     enabled: boolean;
+    webIfc: WEBIFC.IfcAPI;
+    private _material;
+    private _spatialTree;
+    private _metaData;
+    private _fragmentInstances;
+    private _civil;
+    private _propertyExporter;
+    private _visitedFragments;
+    private _materialT;
     constructor(components: Components);
-    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
-    delete(world: World): void;
     dispose(): void;
-    update(delta?: number): void | Promise<void>;
+    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
+    readIfcFile(data: Uint8Array): Promise<number>;
+    private getAllGeometries;
+    cleanUp(): void;
+    private getMesh;
+    private getGeometry;
+    private autoSetWasm;
 }
 import * as THREE from "three";
-import { Components } from "../../core/Components";
-import { SimpleCamera } from "../../core";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
-/**
- * A flexible camera that uses
- * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
- * easily control the camera in 2D and 3D. It supports multiple navigation
- * modes, such as 2D floor plan navigation, first person and 3D orbit.
- */
-export declare class OrthoPerspectiveCamera extends SimpleCamera {
-    /**
-     * The current {@link NavigationMode}.
-     */
-    mode: NavigationMode;
-    readonly projection: ProjectionManager;
-    readonly threeOrtho: THREE.OrthographicCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    get current(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
-     *
-     * @param mode - The {@link NavigationMode} to set.
-     */
-    set(mode: NavModeID): void;
-    /**
-     * Make the camera view fit all the specified meshes.
-     *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
-     */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
-    /**
-     * Allows or prevents all user input.
-     *
-     * @param active - whether to enable or disable user inputs.
-     */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoCameraAspect;
-}
-import { Component, Components, Disposable, Updateable, World, Event } from "../../core";
-import { MiniMap } from "./src";
-export declare class MiniMaps extends Component implements Updateable, Disposable {
-    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
-    readonly onAfterUpdate: Event<unknown>;
-    readonly onBeforeUpdate: Event<unknown>;
-    readonly onDisposed: Event<unknown>;
-    enabled: boolean;
-    list: Map<string, MiniMap>;
-    constructor(components: Components);
-    create(world: World): MiniMap;
-    delete(id: string): void;
-    dispose(): void | Promise<void>;
-    update(): void;
+export interface MeasureEdge {
+    distance: number;
+    points: THREE.Vector3[];
 }
-import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-/**
- * Object to export all the properties from an IFC to a JS object.
- */
-export declare class IfcJsonExporter {
-    /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc]{@link https://github.com/ThatOpen/engine_web-ifc} to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
-     */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+export declare class MeasurementUtils {
+    static getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    private static getFaceData;
+    static getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    private static round;
 }
 import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
 import * as FRAGS from "@thatopen/fragments";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Disposable, Event, Component, Components } from "../../core";
-import { QueryGroup } from "./src/types";
-export interface QueryResult {
-    [modelID: string]: {
-        modelEntities: Set<number>;
-        otherEntities: Set<number>;
-    };
-}
-export interface IndexedModels {
-    [modelID: string]: {
-        [expressID: number]: Set<number>;
+import { Disposable, Component, Event, Components } from "../../core";
+export interface Classification {
+    [system: string]: {
+        [className: string]: FRAGS.FragmentIdMap;
     };
 }
-export declare class IfcPropertiesFinder extends Component implements Disposable {
-    readonly onFound: Event<FRAGS.FragmentIdMap>;
+export declare class FragmentClassifier extends Component implements Disposable {
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    list: Classification;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    enabled: boolean;
-    indexedModels: IndexedModels;
-    private readonly _conditionFunctions;
-    private _noHandleAttributes;
     constructor(components: Components);
     private onFragmentsDisposed;
     dispose(): void;
-    private indexEntityRelations;
-    find(groups: QueryGroup[], queryModels?: FragmentsGroup[]): Promise<FRAGS.FragmentIdMap>;
-    private toFragmentMap;
-    private simpleQuery;
-    private getMatchingEntities;
-    private combineArrays;
-    private getCommonElements;
-    private arrayIntersection;
-    private arrayUnion;
-    private getConditionFunctions;
+    remove(guid: string): void;
+    find(filter?: {
+        [name: string]: string[];
+    }): FRAGS.FragmentIdMap;
+    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    byEntity(group: FRAGS.FragmentsGroup): void;
+    byStorey(group: FRAGS.FragmentsGroup): void;
+    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    resetColor(items: FRAGS.FragmentIdMap): void;
+    private saveItem;
 }
 import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Disposable, Event, Components } from "../../core";
-type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
-type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
-type NumericPropTypes = "IfcInteger" | "IfcReal";
-interface ChangeMap {
-    [modelID: string]: Set<number>;
-}
-interface AttributeListener {
-    [modelID: string]: {
-        [expressID: number]: {
-            [attributeName: string]: Event<String | Boolean | Number>;
+import { AsyncEvent, Component, Disposable, Event } from "../../core";
+import { PropertiesStreamingSettings } from "../IfcGeometryTiler";
+export declare class IfcPropertiesTiler extends Component implements Disposable {
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
         };
-    };
-}
-export declare class IfcPropertiesManager extends Component implements Disposable {
-    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    readonly onRequestFile: Event<unknown>;
-    ifcToExport: ArrayBuffer | null;
-    readonly onElementToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        elementID: number;
-    }>;
-    readonly onPropToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        propID: number;
-    }>;
-    readonly onPsetRemoved: Event<{
-        model: FragmentsGroup;
-        psetID: number;
     }>;
-    readonly onDataChanged: Event<{
-        model: FragmentsGroup;
-        expressID: number;
+    onProgress: AsyncEvent<number>;
+    onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    enabled: boolean;
+    settings: PropertiesStreamingSettings;
+    webIfc: WEBIFC.IfcAPI;
+    dispose(): Promise<void>;
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private cleanUp;
+}
+import * as WEBIFC from "web-ifc";
+import { Components, Disposable, Event, Component } from "../../core";
+import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
+export declare class IfcGeometryTiler extends Component implements Disposable {
+    static readonly uuid: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
+    onGeometryStreamed: Event<{
+        buffer: Uint8Array;
+        data: StreamedGeometries;
     }>;
-    wasm: {
-        path: string;
-        absolute: boolean;
-    };
+    onAssetStreamed: Event<StreamedAsset[]>;
+    onProgress: Event<number>;
+    onIfcLoaded: Event<Uint8Array>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    settings: IfcStreamingSettings;
     enabled: boolean;
-    attributeListeners: AttributeListener;
-    selectedModel?: FragmentsGroup;
-    private _changeMap;
+    webIfc: WEBIFC.IfcAPI;
+    private _spatialTree;
+    private _metaData;
+    private _visitedGeometries;
+    private _streamSerializer;
+    private _geometries;
+    private _geometryCount;
+    private _civil;
+    private _groupSerializer;
+    private _assets;
+    private _meshesWithHoles;
     constructor(components: Components);
-    get(): ChangeMap;
     dispose(): void;
-    private increaseMaxID;
-    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
-    private newGUID;
-    private getOwnerHistory;
-    private registerChange;
-    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
-    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
-        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
-        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
-    }>;
-    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
-    private newSingleProperty;
-    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
-    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
-    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
-    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
-    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllGeometries;
+    private cleanUp;
+    private getMesh;
+    private getGeometry;
+    private streamAssets;
+    private streamGeometries;
 }
-export {};
-import { Components } from "../Components";
-import { MeshCullerRenderer, CullerRendererSettings } from "./src";
-import { Component, Event, Disposable, World } from "../Types";
+import { Fragment, FragmentsGroup } from "@thatopen/fragments";
+import * as THREE from "three";
+import { Component, Components, Event, Disposable } from "../../core";
 /**
- * A tool to handle big scenes efficiently by automatically hiding the objects
- * that are not visible to the camera.
+ * Object that can efficiently load binary files that contain
+ * [fragment geometry](https://github.com/ThatOpen/engine_fragment).
  */
-export declare class Cullers extends Component implements Disposable {
-    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
-    private _enabled;
-    list: Map<string, MeshCullerRenderer>;
+export declare class FragmentManager extends Component implements Disposable {
+    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
+    readonly onFragmentsLoaded: Event<FragmentsGroup>;
+    readonly onFragmentsDisposed: Event<{
+        groupID: string;
+        fragmentIDs: string[];
+    }>;
+    /** All the created [fragments](https://github.com/ThatOpen/engine_fragment). */
+    readonly list: Map<string, Fragment>;
+    readonly groups: Map<string, FragmentsGroup>;
     /** {@link Component.enabled} */
-    get enabled(): boolean;
-    set enabled(value: boolean);
+    enabled: boolean;
+    baseCoordinationModel: string;
+    private _loader;
+    /** The list of meshes of the created fragments. */
+    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
     constructor(components: Components);
-    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
-    delete(world: World): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
+    disposeGroup(group: FragmentsGroup): void;
+    /**
+     * Loads one or many fragments into the scene.
+     * @param data - the bytes containing the data for the fragments to load.
+     * @param coordinate - whether this fragmentsgroup should be federated with the others.
+     * @returns the list of IDs of the loaded fragments.
+     */
+    load(data: Uint8Array, coordinate?: boolean): FragmentsGroup;
+    /**
+     * Export the specified fragments.
+     * @param group - the fragments group to be exported.
+     * @returns the exported data as binary buffer.
+     */
+    export(group: FragmentsGroup): Uint8Array;
+    coordinate(models?: FragmentsGroup[]): void;
 }
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Disposable, Event, Component, Components } from "../../core";
-import { RelationsMap, ModelsRelationMap, InverseAttributes, InverseAttribute } from "./src/types";
+import * as THREE from "three";
+export declare function obbFromPoints(vertices: ArrayLike<number>): {
+    center: THREE.Vector3;
+    halfSizes: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    transformation: THREE.Matrix4;
+};
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
+import * as THREE from "three";
+import { Component, Components, Event, World, Disposable } from "../core";
+export interface VertexPickerConfig {
+    showOnlyVertex: boolean;
+    snapDistance: number;
+    previewElement: HTMLElement;
+}
+export declare class VertexPicker extends Component implements Disposable {
+    onVertexFound: Event<THREE.Vector3>;
+    onVertexLost: Event<THREE.Vector3>;
+    components: Components;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
+    private _workingPlane;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    [Symbol.dispose](): void;
+    set workingPlane(plane: THREE.Plane | null);
+    get workingPlane(): THREE.Plane | null;
+    set config(value: Partial<VertexPickerConfig>);
+    get config(): Partial<VertexPickerConfig>;
+    dispose(): void;
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
+import { Component, Disposable, Event } from "../Types";
 /**
- * Indexer for IFC entities, facilitating the indexing and retrieval of IFC entity relationships.
- * It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations.
+ * The entry point of the Components library.
+ * It can:
+ * - Create and access all the components of the library.
+ * - Update all the updatable components automatically.
+ * - Dispose all the components, preventing memory leaks.
  */
-export declare class IfcRelationsIndexer extends Component implements Disposable {
-    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+export declare class Components implements Disposable {
+    static readonly release = "1.4.21";
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    readonly onDisposed: Event<void>;
+    /** The list of components created in this app. */
+    readonly list: Map<string, Component>;
+    /** If disabled, the animation loop will be stopped. */
     enabled: boolean;
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
-    private _relToAttributesMap;
+    private _clock;
+    add(uuid: string, instance: Component): void;
     /**
-     * Array of inverse attribute names.
-     * This array is used to define the inverse attributes that the indexer will process and index.
+     * Retrieves a component. If it already exists in this app, it returns the instance of the component. If it
+     * doesn't exist, it will instance it automatically.
+     *
+     * @param Component - The component to get or create.
      */
-    readonly inverseAttributes: InverseAttributes;
+    get<U extends Component>(Component: new (components: Components) => U): U;
+    constructor();
     /**
-     * Holds the relationship mappings for each model processed by the indexer.
-     * The structure is a map where each key is a model's UUID, and the value is another map.
-     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
-     * representing a specific relation type, and the value is an array of expressIDs of entities
-     * that are related through that relation type. This structure allows for efficient querying
-     * of entity relationships within a model.
+     * Initializes the library. It should be called at the start of the app after
+     * initializing the scene, the renderer and the
+     * camera. Additionally, if any component that need a raycaster is
+     * used, the {@link raycaster} will need to be initialized.
      */
-    readonly relationMaps: ModelsRelationMap;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    private getAttributeRels;
+    init(): void;
     /**
-     * Adds a relation map to the model's relations map.
+     * Disposes the memory of all the components and tools of this instance of
+     * the library. A memory leak will be created if:
      *
-     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
-     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
+     * - An instance of the library ends up out of scope and this function isn't
+     * called. This is especially relevant in Single Page Applications (React,
+     * Angular, Vue, etc).
      *
-     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
-     */
-    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
-    /**
-     * Processes a given model to index its IFC entities relations based on predefined inverse attributes.
-     * This method iterates through each specified inverse attribute, retrieves the corresponding relations,
-     * and maps them in a structured way to facilitate quick access to related entities.
-     *
-     * The process involves querying the model for each relation type associated with the inverse attributes
-     * and updating the internal relationMaps with the relationships found. This map is keyed by the model's UUID
-     * and contains a nested map where each key is an entity's expressID and its value is another map.
-     * This inner map's keys are the indices of the inverse attributes, and its values are arrays of expressIDs
-     * of entities that are related through that attribute.
+     * - Any of the objects of this instance (meshes, geometries, etc) is
+     * referenced by a reference type (object or array).
      *
-     * @param model The 'FragmentsGroup' model to be processed. It must have properties loaded.
-     * @returns A promise that resolves to the relations map for the processed model. This map is a detailed
-     * representation of the relations indexed by entity expressIDs and relation types.
-     * @throws An error if the model does not have properties loaded.
-     */
-    process(model: FragmentsGroup): Promise<RelationsMap>;
-    /**
-     * Processes a given model from a WebIfc API to index its IFC entities relations based on predefined inverse attributes.
+     * You can learn more about how Three.js handles memory leaks
+     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
      *
-     * @param ifcApi - The WebIfc API instance from which to retrieve the model's properties.
-     * @param modelID - The unique identifier of the model within the WebIfc API.
-     * @returns A promise that resolves to the relations map for the processed model.
-     *          This map is a detailed representation of the relations indexed by entity expressIDs and relation types.
      */
-    processFromWebIfc(ifcApi: WEBIFC.IfcAPI, modelID: number): Promise<RelationsMap>;
+    dispose(): void;
+    private update;
+    private static setupBVH;
+}
+import { Component, Disposable, World, Event } from "../Types";
+import { SimpleRaycaster } from "./src";
+import { Components } from "../Components";
+export declare class Raycasters extends Component implements Disposable {
+    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+    enabled: boolean;
+    list: Map<string, SimpleRaycaster>;
+    onDisposed: Event<unknown>;
+    constructor(components: Components);
+    get(world: World): SimpleRaycaster;
+    delete(world: World): void;
+    dispose(): void;
+}
+import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
+import { Components } from "../Components";
+import { SimpleWorld } from "./src";
+export declare class Worlds extends Component implements Updateable, Disposable {
+    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
+    readonly onAfterUpdate: Event<unknown>;
+    readonly onBeforeUpdate: Event<unknown>;
+    readonly onDisposed: Event<unknown>;
+    list: Map<string, World>;
+    enabled: boolean;
+    constructor(components: Components);
+    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
+    delete(world: World): void;
+    dispose(): void;
+    update(delta?: number): void | Promise<void>;
+}
+import * as THREE from "three";
+import { Components } from "../Components";
+import { Component } from "../Types";
+/**
+ * A tool to safely remove meshes and geometries from memory to
+ * [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ */
+export declare class Disposer extends Component {
+    private _disposedComponents;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
+    constructor(components: Components);
     /**
-     * Retrieves the relations of a specific entity within a model based on the given relation name.
-     * This method searches the indexed relation maps for the specified model and entity,
-     * returning the IDs of related entities if a match is found.
-     *
-     * @param model The 'FragmentsGroup' model containing the entity.
-     * @param expressID The unique identifier of the entity within the model.
-     * @param relationName The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
-     * @returns An array of express IDs representing the related entities, or 'null' if no relations are found
-     * or the specified relation name is not indexed.
+     * {@link Component.uuid}.
+     * @return the list of UUIDs of deleted components.
      */
-    getEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute): number[] | null;
+    get(): Set<string>;
     /**
-     * Serializes the relations of a given relation map into a JSON string.
-     * This method iterates through the relations in the given map, organizing them into a structured object where each key is an expressID of an entity,
-     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
-     * The resulting object is then serialized into a JSON string.
+     * Removes a mesh, its geometry and its materials from memory. If you are
+     * using any of these in other parts of the application, make sure that you
+     * remove them from the mesh before disposing it.
      *
-     * @param relationMap - The map of relations to be serialized. The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
-     * @returns A JSON string representing the serialized relations of the given relation map.
-     */
-    serializeRelations(relationMap: RelationsMap): string;
-    /**
-     * Serializes the relations of a specific model into a JSON string.
-     * This method iterates through the relations indexed for the given model,
-     * organizing them into a structured object where each key is an expressID of an entity,
-     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
-     * The resulting object is then serialized into a JSON string.
+     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
+     * to remove.
      *
-     * @param model The 'FragmentsGroup' model whose relations are to be serialized.
-     * @returns A JSON string representing the serialized relations of the specified model.
-     * If the model has no indexed relations, 'null' is returned.
-     */
-    serializeModelRelations(model: FragmentsGroup): string | null;
-    /**
-     * Serializes all relations of every model processed by the indexer into a JSON string.
-     * This method iterates through each model's relations indexed in 'relationMaps', organizing them
-     * into a structured JSON object. Each top-level key in this object corresponds to a model's UUID,
-     * and its value is another object mapping entity expressIDs to their related entities, categorized
-     * by relation types. The structure facilitates easy access to any entity's relations across all models.
+     * @param materials - whether to dispose the materials of the mesh.
      *
-     * @returns A JSON string representing the serialized relations of all models processed by the indexer.
-     *          If no relations have been indexed, an empty object is returned as a JSON string.
+     * @param recursive - whether to recursively dispose the children of the mesh.
      */
-    serializeAllRelations(): string;
+    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
     /**
-     * Converts a JSON string representing relations between entities into a structured map.
-     * This method parses the JSON string to reconstruct the relations map that indexes
-     * entity relations by their express IDs. The outer map keys are the express IDs of entities,
-     * and the values are maps where each key is a relation type ID and its value is an array
-     * of express IDs of entities related through that relation type.
+     * Disposes a geometry from memory.
      *
-     * @param json The JSON string to be parsed into the relations map.
-     * @returns A 'Map' where the key is the express ID of an entity as a number, and the value
-     * is another 'Map'. This inner map's key is the relation type ID as a number, and its value
-     * is an array of express IDs (as numbers) of entities related through that relation type.
-     */
-    getRelationsMapFromJSON(json: string): RelationsMap;
-    /**
-     * Disposes the component, cleaning up resources and detaching event listeners.
-     * This ensures that the component is properly cleaned up and does not leave behind any
-     * references that could prevent garbage collection.
+     * @param geometry - the
+     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+     * to remove.
      */
+    disposeGeometry(geometry: THREE.BufferGeometry): void;
+    private disposeGeometryAndMaterials;
+    private disposeChildren;
+    private static disposeMaterial;
+}
+import { Component, Disposable, World, Event } from "../Types";
+import { GridConfig, SimpleGrid } from "./src";
+export declare class Grids extends Component implements Disposable {
+    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
+    list: Map<string, SimpleGrid>;
+    onDisposed: Event<unknown>;
+    config: Required<GridConfig>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    create(world: World): void;
+    delete(world: World): void;
     dispose(): void;
 }
 import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Components, Disposable, Event } from "../../core";
+import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
+import { SimplePlane } from "./src";
+import { Components } from "../Components";
 /**
- * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but
- * it's fast, and should suffice for general use cases such as camera zooming or general boundary determination.
+ * A lightweight component to easily create and handle
+ * [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes).
+ *
+ * @param components - the instance of {@link Components} used.
+ * @param planeType - the type of plane to be used by the clipper.
+ * E.g. {@link SimplePlane}.
  */
-export declare class BoundingBoxes extends Component implements Disposable {
-    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
-    /** {@link Component.enabled} */
-    enabled: boolean;
+export declare class Clipper<T extends SimplePlane> extends Component implements Createable, Disposable, Hideable {
+    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
+    /** {@link Createable.onAfterCreate} */
+    readonly onAfterCreate: Event<T>;
+    /** {@link Createable.onAfterDelete} */
+    readonly onAfterDelete: Event<T>;
+    /** Event that fires when the user starts dragging a clipping plane. */
+    readonly onBeforeDrag: Event<void>;
+    /** Event that fires when the user stops dragging a clipping plane. */
+    readonly onAfterDrag: Event<void>;
+    readonly onBeforeCreate: Event<unknown>;
+    readonly onBeforeCancel: Event<unknown>;
+    readonly onAfterCancel: Event<unknown>;
+    readonly onBeforeDelete: Event<unknown>;
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    private _absoluteMin;
-    private _absoluteMax;
-    private _meshes;
+    readonly onDisposed: Event<string>;
+    /**
+     * Whether to force the clipping plane to be orthogonal in the Y direction
+     * (up). This is desirable when clipping a building horizontally and a
+     * clipping plane is created in its roof, which might have a slight
+     * slope for draining purposes.
+     */
+    orthogonalY: boolean;
+    /**
+     * The tolerance that determines whether an almost-horizontal clipping plane
+     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
+     * has to be 'true' for this to apply.
+     */
+    toleranceOrthogonalY: number;
+    list: T[];
+    protected PlaneType: new (...args: any) => SimplePlane | T;
+    /** The material used in all the clipping planes. */
+    protected _material: THREE.MeshBasicMaterial;
+    private _size;
+    private _enabled;
+    private _visible;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The material of the clipping plane representation. */
+    get material(): THREE.MeshBasicMaterial;
+    /** The material of the clipping plane representation. */
+    set material(material: THREE.MeshBasicMaterial);
+    /** The size of the geometric representation of the clippings planes. */
+    get size(): number;
+    /** The size of the geometric representation of the clippings planes. */
+    set size(size: number);
     constructor(components: Components);
-    static getDimensions(bbox: THREE.Box3): {
-        width: number;
-        height: number;
-        depth: number;
-        center: THREE.Vector3;
-    };
-    static newBound(positive: boolean): THREE.Vector3;
-    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
+    endCreation(): void;
+    cancelCreation(): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
-    get(): THREE.Box3;
-    getSphere(): THREE.Sphere;
-    getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
-    reset(): void;
-    add(group: FragmentsGroup): void;
-    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
-    private static getFragmentBounds;
-}
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
-export declare class FragmentHider extends Component {
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
-    enabled: boolean;
-    constructor(components: Components);
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
-}
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Disposable, Component, Event, Components } from "../../core";
-export interface Classification {
-    [system: string]: {
-        [className: string]: FRAGS.FragmentIdMap;
-    };
+    /** {@link Createable.create} */
+    create(world: World): void;
+    /**
+     * Creates a plane in a certain place and with a certain orientation,
+     * without the need of the mouse.
+     *
+     * @param world - the world where this plane should be created.
+     * @param normal - the orientation of the clipping plane.
+     * @param point - the position of the clipping plane.
+     * navigation.
+     */
+    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): T;
+    /**
+     * {@link Createable.delete}
+     *
+     * @param world - the world where the plane to delete is.
+     * @param plane - the plane to delete. If undefined, the first plane
+     * found under the cursor will be deleted.
+     */
+    delete(world: World, plane?: T): void;
+    /** Deletes all the existing clipping planes. */
+    deleteAll(): void;
+    private deletePlane;
+    private pickPlane;
+    private getAllPlaneMeshes;
+    private createPlaneFromIntersection;
+    private getWorldNormal;
+    private normalizePlaneDirectionY;
+    private newPlane;
+    protected newPlaneInstance(world: World, point: THREE.Vector3, normal: THREE.Vector3): T;
+    private updateMaterialsAndPlanes;
+    private _onStartDragging;
+    private _onEndDragging;
 }
-export declare class FragmentClassifier extends Component implements Disposable {
-    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    list: Classification;
-    /** {@link Disposable.onDisposed} */
+import { Component, Components, Disposable, Updateable, World, Event } from "../../core";
+import { MiniMap } from "./src";
+export declare class MiniMaps extends Component implements Updateable, Disposable {
+    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
+    readonly onAfterUpdate: Event<unknown>;
+    readonly onBeforeUpdate: Event<unknown>;
     readonly onDisposed: Event<unknown>;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    dispose(): void;
-    remove(guid: string): void;
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
-    byEntity(group: FRAGS.FragmentsGroup): void;
-    byStorey(group: FRAGS.FragmentsGroup): void;
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    private saveItem;
-}
-import { Component, Disposable, Event, Components } from "../../core";
-export declare class FragmentExploder extends Component implements Disposable {
-    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
     enabled: boolean;
-    height: number;
-    groupName: string;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    list: Set<string>;
+    list: Map<string, MiniMap>;
     constructor(components: Components);
-    dispose(): void;
-    explode(): void;
-    reset(): void;
+    create(world: World): MiniMap;
+    delete(id: string): void;
+    dispose(): void | Promise<void>;
     update(): void;
 }
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
-export declare class FragmentIfcLoader extends Component implements Disposable {
-    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
-    readonly onIfcStartedLoading: Event<void>;
-    readonly onSetup: Event<void>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    settings: IfcFragmentSettings;
-    enabled: boolean;
-    webIfc: WEBIFC.IfcAPI;
-    private _material;
-    private _spatialTree;
-    private _metaData;
-    private _fragmentInstances;
-    private _civil;
-    private _propertyExporter;
-    private _visitedFragments;
-    private _materialT;
-    constructor(components: Components);
-    dispose(): void;
-    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
-    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
-    readIfcFile(data: Uint8Array): Promise<number>;
-    private getAllGeometries;
-    cleanUp(): void;
-    private getMesh;
-    private getGeometry;
-    private autoSetWasm;
-}
-import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../core";
-import { PropertiesStreamingSettings } from "../IfcGeometryTiler";
-export declare class IfcPropertiesTiler extends Component implements Disposable {
-    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
-    onPropertiesStreamed: AsyncEvent<{
-        type: number;
-        data: {
-            [id: number]: any;
-        };
-    }>;
-    onProgress: AsyncEvent<number>;
-    onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    enabled: boolean;
-    settings: PropertiesStreamingSettings;
-    webIfc: WEBIFC.IfcAPI;
-    dispose(): Promise<void>;
-    streamFromBuffer(data: Uint8Array): Promise<void>;
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllProperties;
-    private cleanUp;
-}
-import * as WEBIFC from "web-ifc";
-import { Components, Disposable, Event, Component } from "../../core";
-import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
-export declare class IfcGeometryTiler extends Component implements Disposable {
-    static readonly uuid: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
-    onGeometryStreamed: Event<{
-        buffer: Uint8Array;
-        data: StreamedGeometries;
-    }>;
-    onAssetStreamed: Event<StreamedAsset[]>;
-    onProgress: Event<number>;
-    onIfcLoaded: Event<Uint8Array>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    settings: IfcStreamingSettings;
-    enabled: boolean;
-    webIfc: WEBIFC.IfcAPI;
-    private _spatialTree;
-    private _metaData;
-    private _visitedGeometries;
-    private _streamSerializer;
-    private _geometries;
-    private _geometryCount;
-    private _civil;
-    private _groupSerializer;
-    private _assets;
-    private _meshesWithHoles;
-    constructor(components: Components);
-    dispose(): void;
-    streamFromBuffer(data: Uint8Array): Promise<void>;
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllGeometries;
-    private cleanUp;
-    private getMesh;
-    private getGeometry;
-    private streamAssets;
-    private streamGeometries;
-}
-import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
-import { Component, Components, Event, Disposable } from "../../core";
+import { Component, Disposable, Event } from "../Types";
+import { Components } from "../Components";
 /**
- * Object that can efficiently load binary files that contain
- * [fragment geometry](https://github.com/ThatOpen/engine_fragment).
+ * A tool to easily handle the materials of massive amounts of
+ * objects and scene background easily.
  */
-export declare class FragmentManager extends Component implements Disposable {
-    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    readonly onFragmentsLoaded: Event<FragmentsGroup>;
-    readonly onFragmentsDisposed: Event<{
-        groupID: string;
-        fragmentIDs: string[];
-    }>;
-    /** All the created [fragments](https://github.com/ThatOpen/engine_fragment). */
-    readonly list: Map<string, Fragment>;
-    readonly groups: Map<string, FragmentsGroup>;
+export declare class Materials extends Component implements Disposable {
+    static readonly uuid: "24989d27-fa2f-4797-8b08-35918f74e502";
     /** {@link Component.enabled} */
     enabled: boolean;
-    baseCoordinationModel: string;
-    private _loader;
-    /** The list of meshes of the created fragments. */
-    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    list: {
+        [id: string]: {
+            material: THREE.Material;
+            meshes: Set<THREE.Mesh | THREE.InstancedMesh>;
+        };
+    };
+    private _originals;
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    disposeGroup(group: FragmentsGroup): void;
     /**
-     * Loads one or many fragments into the scene.
-     * @param data - the bytes containing the data for the fragments to load.
-     * @param coordinate - whether this fragmentsgroup should be federated with the others.
-     * @returns the list of IDs of the loaded fragments.
+     * Turns the specified material styles on or off.
+     *
+     * @param active whether to turn it on or off.
+     * @param ids the ids of the style to turn on or off.
      */
-    load(data: Uint8Array, coordinate?: boolean): FragmentsGroup;
+    set(active: boolean, ids?: string[]): void;
     /**
-     * Export the specified fragments.
-     * @param group - the fragments group to be exported.
-     * @returns the exported data as binary buffer.
+     * Creates a new material style.
+     * @param id the identifier of the style to create.
+     * @param material the material of the style.
      */
-    export(group: FragmentsGroup): Uint8Array;
-    coordinate(models?: FragmentsGroup[]): void;
+    addMaterial(id: string, material: THREE.Material): void;
+    /**
+     * Assign meshes to a certain style.
+     * @param id the identifier of the style.
+     * @param meshes the meshes to assign to the style.
+     */
+    addMeshes(id: string, meshes: THREE.Mesh[]): void;
+    /**
+     * Remove meshes from a certain style.
+     * @param id the identifier of the style.
+     * @param meshes the meshes to assign to the style.
+     */
+    removeMeshes(id: string, meshes: THREE.Mesh[]): void;
 }
 import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
-}
-import * as THREE from "three";
-import { Component, Components, Event, World, Disposable } from "../core";
-export interface VertexPickerConfig {
-    showOnlyVertex: boolean;
-    snapDistance: number;
-    previewElement: HTMLElement;
+import { Components } from "../../core/Components";
+import { SimpleCamera } from "../../core";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+/**
+ * A flexible camera that uses
+ * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
+ * easily control the camera in 2D and 3D. It supports multiple navigation
+ * modes, such as 2D floor plan navigation, first person and 3D orbit.
+ */
+export declare class OrthoPerspectiveCamera extends SimpleCamera {
+    /**
+     * The current {@link NavigationMode}.
+     */
+    mode: NavigationMode;
+    readonly projection: ProjectionManager;
+    readonly threeOrtho: THREE.OrthographicCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    get current(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets a new {@link NavigationMode} and disables the previous one.
+     *
+     * @param mode - The {@link NavigationMode} to set.
+     */
+    set(mode: NavModeID): void;
+    /**
+     * Make the camera view fit all the specified meshes.
+     *
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
+     */
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    /**
+     * Allows or prevents all user input.
+     *
+     * @param active - whether to enable or disable user inputs.
+     */
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoCameraAspect;
 }
-export declare class VertexPicker extends Component implements Disposable {
-    onVertexFound: Event<THREE.Vector3>;
-    onVertexLost: Event<THREE.Vector3>;
-    components: Components;
-    private _pickedPoint;
-    private _config;
+import { Components } from "../Components";
+import { MeshCullerRenderer, CullerRendererSettings } from "./src";
+import { Component, Event, Disposable, World } from "../Types";
+/**
+ * A tool to handle big scenes efficiently by automatically hiding the objects
+ * that are not visible to the camera.
+ */
+export declare class Cullers extends Component implements Disposable {
+    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
     private _enabled;
-    private _workingPlane;
+    list: Map<string, MeshCullerRenderer>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    set enabled(value: boolean);
+    /** {@link Component.enabled} */
     get enabled(): boolean;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    [Symbol.dispose](): void;
-    set workingPlane(plane: THREE.Plane | null);
-    get workingPlane(): THREE.Plane | null;
-    set config(value: Partial<VertexPickerConfig>);
-    get config(): Partial<VertexPickerConfig>;
+    set enabled(value: boolean);
+    constructor(components: Components);
+    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
     dispose(): void;
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
 }
-export declare const IfcElements: {
-    [key: number]: string;
-};
 import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
+import * as FRAG from "@thatopen/fragments";
+/**
+ * Object to export all the properties from an IFC to a JS object.
+ */
+export declare class IfcJsonExporter {
+    /**
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc]{@link https://github.com/ThatOpen/engine_web-ifc} to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
+     */
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
 import * as FRAGS from "@thatopen/fragments";
-export declare class IfcPropertiesUtils {
-    static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
-    static findItemByGuid(model: FRAGS.FragmentsGroup, guid: string): Promise<{
-        [attribute: string]: any;
-    } | null>;
-    static getRelationMap(model: FRAGS.FragmentsGroup, relationType: number, onElementsFound?: (relatingID: number, relatedIDs: number[]) => Promise<void>): Promise<{
-        [relatingID: number]: number[];
-    }>;
-    static getQsetQuantities(model: FRAGS.FragmentsGroup, expressID: number, onQuantityFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetProps(model: FRAGS.FragmentsGroup, expressID: number, onPropFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetRel(model: FRAGS.FragmentsGroup, psetID: number): Promise<number | null>;
-    static getQsetRel(model: FRAGS.FragmentsGroup, qsetID: number): Promise<number | null>;
-    static getEntityName(model: FRAGS.FragmentsGroup, entityID: number): Promise<{
-        key: string | null;
-        name: string | null;
-    }>;
-    static getQuantityValue(model: FRAGS.FragmentsGroup, quantityID: number): Promise<{
-        key: string | null;
-        value: number | null;
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+import { QueryGroup } from "./src/types";
+export interface QueryResult {
+    [modelID: string]: {
+        modelEntities: Set<number>;
+        otherEntities: Set<number>;
+    };
+}
+export interface IndexedModels {
+    [modelID: string]: {
+        [expressID: number]: Set<number>;
+    };
+}
+export declare class IfcPropertiesFinder extends Component implements Disposable {
+    readonly onFound: Event<FRAGS.FragmentIdMap>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    enabled: boolean;
+    indexedModels: IndexedModels;
+    private readonly _conditionFunctions;
+    private _noHandleAttributes;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    dispose(): void;
+    private indexEntityRelations;
+    find(groups: QueryGroup[], queryModels?: FragmentsGroup[]): Promise<FRAGS.FragmentIdMap>;
+    private toFragmentMap;
+    private simpleQuery;
+    private getMatchingEntities;
+    private combineArrays;
+    private getCommonElements;
+    private arrayIntersection;
+    private arrayUnion;
+    private getConditionFunctions;
+}
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+import { RelationsMap, ModelsRelationMap, InverseAttributes, InverseAttribute } from "./src/types";
+/**
+ * Indexer for IFC entities, facilitating the indexing and retrieval of IFC entity relationships.
+ * It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations.
+ */
+export declare class IfcRelationsIndexer extends Component implements Disposable {
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    enabled: boolean;
+    readonly onRelationsIndexed: Event<{
+        modelID: string;
+        relationsMap: RelationsMap;
     }>;
-    static isRel(expressID: number): boolean;
-    static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
-    static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
+    private _relToAttributesMap;
+    /**
+     * Array of inverse attribute names.
+     * This array is used to define the inverse attributes that the indexer will process and index.
+     */
+    readonly inverseAttributes: InverseAttributes;
+    /**
+     * Holds the relationship mappings for each model processed by the indexer.
+     * The structure is a map where each key is a model's UUID, and the value is another map.
+     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
+     * representing a specific relation type, and the value is an array of expressIDs of entities
+     * that are related through that relation type. This structure allows for efficient querying
+     * of entity relationships within a model.
+     */
+    readonly relationMaps: ModelsRelationMap;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    private getAttributeRels;
+    /**
+     * Adds a relation map to the model's relations map.
+     *
+     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
+     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
+     *
+     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
+     */
+    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
+    /**
+     * Processes a given model to index its IFC entities relations based on predefined inverse attributes.
+     * This method iterates through each specified inverse attribute, retrieves the corresponding relations,
+     * and maps them in a structured way to facilitate quick access to related entities.
+     *
+     * The process involves querying the model for each relation type associated with the inverse attributes
+     * and updating the internal relationMaps with the relationships found. This map is keyed by the model's UUID
+     * and contains a nested map where each key is an entity's expressID and its value is another map.
+     * This inner map's keys are the indices of the inverse attributes, and its values are arrays of expressIDs
+     * of entities that are related through that attribute.
+     *
+     * @param model The 'FragmentsGroup' model to be processed. It must have properties loaded.
+     * @returns A promise that resolves to the relations map for the processed model. This map is a detailed
+     * representation of the relations indexed by entity expressIDs and relation types.
+     * @throws An error if the model does not have properties loaded.
+     */
+    process(model: FragmentsGroup): Promise<RelationsMap>;
+    /**
+     * Processes a given model from a WebIfc API to index its IFC entities relations based on predefined inverse attributes.
+     *
+     * @param ifcApi - The WebIfc API instance from which to retrieve the model's properties.
+     * @param modelID - The unique identifier of the model within the WebIfc API.
+     * @returns A promise that resolves to the relations map for the processed model.
+     *          This map is a detailed representation of the relations indexed by entity expressIDs and relation types.
+     */
+    processFromWebIfc(ifcApi: WEBIFC.IfcAPI, modelID: number): Promise<RelationsMap>;
+    /**
+     * Retrieves the relations of a specific entity within a model based on the given relation name.
+     * This method searches the indexed relation maps for the specified model and entity,
+     * returning the IDs of related entities if a match is found.
+     *
+     * @param model The 'FragmentsGroup' model containing the entity.
+     * @param expressID The unique identifier of the entity within the model.
+     * @param relationName The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
+     * @returns An array of express IDs representing the related entities, or 'null' if no relations are found
+     * or the specified relation name is not indexed.
+     */
+    getEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute): number[] | null;
+    /**
+     * Serializes the relations of a given relation map into a JSON string.
+     * This method iterates through the relations in the given map, organizing them into a structured object where each key is an expressID of an entity,
+     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
+     * The resulting object is then serialized into a JSON string.
+     *
+     * @param relationMap - The map of relations to be serialized. The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
+     * @returns A JSON string representing the serialized relations of the given relation map.
+     */
+    serializeRelations(relationMap: RelationsMap): string;
+    /**
+     * Serializes the relations of a specific model into a JSON string.
+     * This method iterates through the relations indexed for the given model,
+     * organizing them into a structured object where each key is an expressID of an entity,
+     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
+     * The resulting object is then serialized into a JSON string.
+     *
+     * @param model The 'FragmentsGroup' model whose relations are to be serialized.
+     * @returns A JSON string representing the serialized relations of the specified model.
+     * If the model has no indexed relations, 'null' is returned.
+     */
+    serializeModelRelations(model: FragmentsGroup): string | null;
+    /**
+     * Serializes all relations of every model processed by the indexer into a JSON string.
+     * This method iterates through each model's relations indexed in 'relationMaps', organizing them
+     * into a structured JSON object. Each top-level key in this object corresponds to a model's UUID,
+     * and its value is another object mapping entity expressIDs to their related entities, categorized
+     * by relation types. The structure facilitates easy access to any entity's relations across all models.
+     *
+     * @returns A JSON string representing the serialized relations of all models processed by the indexer.
+     *          If no relations have been indexed, an empty object is returned as a JSON string.
+     */
+    serializeAllRelations(): string;
+    /**
+     * Converts a JSON string representing relations between entities into a structured map.
+     * This method parses the JSON string to reconstruct the relations map that indexes
+     * entity relations by their express IDs. The outer map keys are the express IDs of entities,
+     * and the values are maps where each key is a relation type ID and its value is an array
+     * of express IDs of entities related through that relation type.
+     *
+     * @param json The JSON string to be parsed into the relations map.
+     * @returns A 'Map' where the key is the express ID of an entity as a number, and the value
+     * is another 'Map'. This inner map's key is the relation type ID as a number, and its value
+     * is an array of express IDs (as numbers) of entities related through that relation type.
+     */
+    getRelationsMapFromJSON(json: string): RelationsMap;
+    /**
+     * Disposes the component, cleaning up resources and detaching event listeners.
+     * This ensures that the component is properly cleaned up and does not leave behind any
+     * references that could prevent garbage collection.
+     */
+    dispose(): void;
 }
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
-import * as THREE from "three";
-export interface MeasureEdge {
-    distance: number;
-    points: THREE.Vector3[];
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Disposable, Event, Components } from "../../core";
+type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
+type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
+type NumericPropTypes = "IfcInteger" | "IfcReal";
+interface ChangeMap {
+    [modelID: string]: Set<number>;
 }
-export declare class MeasurementUtils {
-    static getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    private static getFaceData;
-    static getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
+interface AttributeListener {
+    [modelID: string]: {
+        [expressID: number]: {
+            [attributeName: string]: Event<String | Boolean | Number>;
+        };
     };
-    private static round;
+}
+export declare class IfcPropertiesManager extends Component implements Disposable {
+    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    readonly onRequestFile: Event<unknown>;
+    ifcToExport: ArrayBuffer | null;
+    readonly onElementToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        elementID: number;
+    }>;
+    readonly onPropToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        propID: number;
+    }>;
+    readonly onPsetRemoved: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+    }>;
+    readonly onDataChanged: Event<{
+        model: FragmentsGroup;
+        expressID: number;
+    }>;
+    wasm: {
+        path: string;
+        absolute: boolean;
+    };
+    enabled: boolean;
+    attributeListeners: AttributeListener;
+    selectedModel?: FragmentsGroup;
+    private _changeMap;
+    constructor(components: Components);
+    get(): ChangeMap;
+    dispose(): void;
+    private increaseMaxID;
+    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
+    private newGUID;
+    private getOwnerHistory;
+    private registerChange;
+    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
+    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
+        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
+        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
+    }>;
+    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
+    private newSingleProperty;
+    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
+    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
+    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
+    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
+    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
+}
+export {};
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
 }
 export declare const GeometryTypes: Set<number>;
 import * as THREE from "three";
@@ -1011,18 +981,48 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     resize(size?: THREE.Vector2): void;
     private updatePlanes;
 }
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
+}
 export declare const relToAttributesMap: Map<number, {
     forRelating?: "IsDecomposedBy" | "Decomposes" | "AssociatedTo" | "HasAssociations" | "ClassificationForObjects" | "IsGroupedBy" | "HasAssignments" | "IsDefinedBy" | "DefinesOcurrence" | "IsTypedBy" | "Types" | "Defines" | "ContainedInStructure" | "ContainsElements" | undefined;
     forRelated?: "IsDecomposedBy" | "Decomposes" | "AssociatedTo" | "HasAssociations" | "ClassificationForObjects" | "IsGroupedBy" | "HasAssignments" | "IsDefinedBy" | "DefinesOcurrence" | "IsTypedBy" | "Types" | "Defines" | "ContainedInStructure" | "ContainsElements" | undefined;
 }>;
-import * as WEBIFC from "web-ifc";
-import { IfcItemsCategories } from "../../../ifc";
-export declare class SpatialStructure {
-    itemsByFloor: IfcItemsCategories;
-    private _units;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    cleanUp(): void;
+export declare const getRelationMap: (properties: Record<string, Record<string, any>>, relationType: number, onElementsFound?: ((relatingID: number, relatedIDs: number[]) => void) | undefined) => {
+    [relatingID: number]: number[];
+};
+import * as FRAGS from "@thatopen/fragments";
+export declare class IfcPropertiesUtils {
+    static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
+    static findItemByGuid(model: FRAGS.FragmentsGroup, guid: string): Promise<{
+        [attribute: string]: any;
+    } | null>;
+    static getRelationMap(model: FRAGS.FragmentsGroup, relationType: number, onElementsFound?: (relatingID: number, relatedIDs: number[]) => Promise<void>): Promise<{
+        [relatingID: number]: number[];
+    }>;
+    static getQsetQuantities(model: FRAGS.FragmentsGroup, expressID: number, onQuantityFound?: (expressID: number) => void): Promise<number[] | null>;
+    static getPsetProps(model: FRAGS.FragmentsGroup, expressID: number, onPropFound?: (expressID: number) => void): Promise<number[] | null>;
+    static getPsetRel(model: FRAGS.FragmentsGroup, psetID: number): Promise<number | null>;
+    static getQsetRel(model: FRAGS.FragmentsGroup, qsetID: number): Promise<number | null>;
+    static getEntityName(model: FRAGS.FragmentsGroup, entityID: number): Promise<{
+        key: string | null;
+        name: string | null;
+    }>;
+    static getQuantityValue(model: FRAGS.FragmentsGroup, quantityID: number): Promise<{
+        key: string | null;
+        value: number | null;
+    }>;
+    static isRel(expressID: number): boolean;
+    static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
+    static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
 }
+export declare const IfcElements: {
+    [key: number]: string;
+};
 import * as THREE from "three";
 import { Disposable, Event } from "../../Types";
 /**
@@ -1049,9 +1049,65 @@ export declare class Mouse implements Disposable {
     private updateMouseInfo;
     private setupEvents;
 }
-export declare const getRelationMap: (properties: Record<string, Record<string, any>>, relationType: number, onElementsFound?: ((relatingID: number, relatedIDs: number[]) => void) | undefined) => {
-    [relatingID: number]: number[];
+export declare const IfcCategoryMap: {
+    [key: number]: string;
 };
+import * as WEBIFC from "web-ifc";
+/** Configuration of the IFC-fragment conversion. */
+export declare class IfcFragmentSettings {
+    /** Whether to extract the IFC properties into a JSON. */
+    includeProperties: boolean;
+    /**
+     * Generate the geometry for categories that are not included by default,
+     * like IFCSPACE.
+     */
+    optionalCategories: number[];
+    /** Whether to use the coordination data coming from the IFC files. */
+    coordinate: boolean;
+    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    wasm: {
+        path: string;
+        absolute: boolean;
+        logLevel?: WEBIFC.LogLevel;
+    };
+    /** List of categories that won't be converted to fragments. */
+    excludedCategories: Set<number>;
+    /** Whether to save the absolute location of all IFC items. */
+    saveLocations: boolean;
+    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    webIfc: WEBIFC.LoaderSettings;
+    autoSetWasm: boolean;
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+import * as THREE from "three";
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+export declare class CivilReader {
+    defLineMat: THREE.LineBasicMaterial;
+    read(webIfc: WEBIFC.IfcAPI): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    get(civilItems: any): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    private getCurves;
+}
+import * as WEBIFC from "web-ifc";
+export declare class IfcMetadataReader {
+    get(webIfc: WEBIFC.IfcAPI, type: number): string;
+}
+import * as WEBIFC from "web-ifc";
+import * as THREE from "three";
+export declare class Units {
+    factor: number;
+    complement: number;
+    apply(matrix: THREE.Matrix4): void;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    private getLengthUnits;
+    private getScaleMatrix;
+}
 import * as THREE from "three";
 import { Components } from "../../Components";
 import { Event, World, Disposable } from "../../Types";
@@ -1088,278 +1144,333 @@ export declare class SimpleRaycaster implements Disposable {
     private intersect;
     private filterClippingPlanes;
 }
-import { NavigationMode } from "./types";
-/**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D,
- * like many BIM tools.
- */
-export declare class PlanMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Plan";
-    private mouseAction1?;
-    private mouseAction2?;
-    private mouseInitialized;
-    private readonly defaultAzimuthSpeed;
-    private readonly defaultPolarSpeed;
-    constructor(camera: any);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
+import { IfcFragmentSettings } from "../../FragmentIfcLoader/src";
+/** Configuration of the IFC-fragment streaming. */
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
+    minGeometrySize: number;
+    minAssetsSize: number;
 }
-import { NavigationMode } from "./types";
-/**
- * A {@link NavigationMode} that allows 3D navigation and panning
- * like in many 3D and CAD softwares.
- */
-export declare class OrbitMode implements NavigationMode {
-    camera: any;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Orbit";
-    constructor(camera: any);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private activateOrbitControls;
+/** Configuration of the IFC-fragment streaming. */
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    propertiesSize: number;
 }
-/**
- * The projection system of the camera.
- */
-export type CameraProjection = "Perspective" | "Orthographic";
-/**
- * The extensible list of supported navigation modes.
- */
-export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
-/**
- * An object that determines the behavior of the camera controls
- * and the user input (e.g. 2D floor plan mode, first person mode, etc).
- */
-export interface NavigationMode {
-    /** The unique ID of this navigation mode. */
-    id: NavModeID;
-    /**
-     * Enable or disable this navigation mode.
-     * When a new navigation mode is enabled, the previous navigation mode
-     * must be disabled.
-     *
-     * @param active - whether to enable or disable this mode.
-     * @param options - any additional data required to enable or disable it.
-     * */
-    set: (active: boolean, options?: any) => void;
-    /** Whether this navigation mode is active or not. */
+export interface StreamedGeometries {
+    [id: number]: {
+        boundingBox: Float32Array;
+        hasHoles: boolean;
+        geometryFile?: string;
+    };
+}
+export interface StreamedAsset {
+    id: number;
+    geometries: {
+        geometryID: number;
+        transformation: number[];
+        color: number[];
+    }[];
+}
+import * as WEBIFC from "web-ifc";
+import { AsyncEvent, Component, Disposable, Event } from "../../../core";
+import { PropertiesStreamingSettings } from "./streaming-settings";
+export declare class FragmentPropsStreamConverter extends Component implements Disposable {
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
+        };
+    }>;
+    onProgress: AsyncEvent<number>;
+    onIndicesStreamed: AsyncEvent<number[][]>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     enabled: boolean;
+    settings: PropertiesStreamingSettings;
+    webIfc: WEBIFC.IfcAPI;
+    dispose(): Promise<void>;
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private getIndices;
+    private cleanUp;
 }
 import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../../core";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
- */
-export declare class ProjectionManager {
-    /**
-     * Event that fires when the {@link CameraProjection} changes.
-     */
-    readonly onChanged: Event<THREE.Camera>;
-    current: CameraProjection;
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    private _component;
-    private _previousDistance;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    constructor(camera: OrthoPerspectiveCamera);
-    /**
-     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
-     *
-     * @param projection - the new projection to set. If it is the current projection,
-     * it will have no effect.
-     */
-    set(projection: CameraProjection): Promise<void>;
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer } from "../../Types";
+import { Components } from "../../Components";
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World {
     /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh).
      */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
+    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    readonly onAfterUpdate: Event<unknown>;
+    readonly onBeforeUpdate: Event<unknown>;
+    enabled: boolean;
+    uuid: string;
+    readonly onDisposed: Event<unknown>;
+    private _scene?;
+    private _camera?;
+    private _renderer;
+    get scene(): T;
+    set scene(scene: T);
+    get camera(): U;
+    set camera(camera: U);
+    get renderer(): S | null;
+    set renderer(renderer: S | null);
+    constructor(components: Components);
+    update(delta?: number): void;
+    dispose(disposeResources?: boolean): void;
 }
-import { NavigationMode } from "./types";
+import * as THREE from "three";
+import { BaseRenderer, Event } from "../../Types";
+import { Components } from "../../Components";
 /**
- * A {@link NavigationMode} that allows first person navigation,
- * simulating FPS video games.
+ * A basic renderer capable of rendering
+ * ([Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
  */
-export declare class FirstPersonMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
+export declare class SimpleRenderer extends BaseRenderer {
     enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "FirstPerson";
-    constructor(camera: any);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private setupFirstPersonCamera;
+    /** The HTML container of the THREE.js canvas where the scene is rendered. */
+    container: HTMLElement;
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<HTMLElement>;
+    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
+    /** {@link Updateable.update} */
+    update(): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Resizeable.getSize}. */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize: (size?: THREE.Vector2) => void;
+    setupEvents(active: boolean): void;
+    private resizeEvent;
+    private setupRenderer;
+    private onContextLost;
+    private onContextBack;
 }
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
+import { Components } from "../../Components";
 /**
- * Simple event handler by
- * [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540).
- * Keep in mind that:
- * - If you want to remove it later, you might want to declare the callback as
- * an object.
- * - If you want to maintain the reference to 'this', you will need to declare
- * the callback as an arrow function.
+ * A basic camera that uses
+ * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
+ * easily control the camera in 2D and 3D. Check out it's API to find out
+ * what features it offers.
  */
-export declare class Event<T> {
+export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<SimpleCamera>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<SimpleCamera>;
+    readonly onAspectUpdated: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    readonly three: THREE.PerspectiveCamera;
+    private _allControls;
     /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
+     * The object that controls the camera. An instance of
+     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
+     * Transforming the camera directly will have no effect: you need to use this
+     * object to move, rotate, look at objects, etc.
      */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
+    get controls(): CameraControls;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(enabled: boolean);
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(_delta: number): void;
     /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
      */
-    remove(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => void;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
 }
 import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Event } from "./event";
-/**
- * Whether this component has to be manually destroyed once you are done with
- * it to prevent
- * [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- * This also ensures that the DOM events created by that component will be
- * cleaned up.
- */
-export interface Disposable {
-    /**
-     * Destroys the object from memory to prevent a
-     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
-     */
-    dispose: () => void | Promise<void>;
-    /** Fired after the tool has been {@link Disposable.dispose()}  */
-    readonly onDisposed: Event<any>;
+import { BaseScene, Configurable, Event } from "../../Types";
+import { Components } from "../../Components";
+export interface SimpleSceneConfig {
+    directionalLight: {
+        color: THREE.Color;
+        intensity: number;
+        position: THREE.Vector3;
+    };
+    ambientLight: {
+        color: THREE.Color;
+        intensity: number;
+    };
 }
 /**
- * Whether the geometric representation of this component can be
- * hidden or shown in the
- * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
+ * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add
+ * objects hierarchically, and easily dispose them when you are finished with it.
+ * @noInheritDoc
  */
-export interface Hideable {
-    /**
-     * Whether the geometric representation of this component is
-     * currently visible or not in the
-     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
-     */
-    visible: boolean;
+export declare class SimpleScene extends BaseScene implements Configurable<{}> {
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    three: THREE.Scene;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<SimpleScene>;
+    config: Required<SimpleSceneConfig>;
+    constructor(components: Components);
+    /** Creates a simple and nice default set up for the scene (e.g. lighting). */
+    setup(config?: Partial<SimpleSceneConfig>): void;
 }
+import * as THREE from "three";
+import { Hideable, Disposable, Event, World } from "../../Types";
+import { Components } from "../../Components";
 /**
- * Whether this component can be resized. The meaning of this can vary depending
- * on the component: resizing a
- * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
- * component could mean changing its resolution, whereas resizing a
- * [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
+ * Each of the planes created by {@link SimpleClipper}.
  */
-export interface Resizeable {
-    /**
-     * Sets size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
-     */
-    resize: (size?: THREE.Vector2) => void;
-    /** Event that fires when the component has been resized. */
-    onResize: Event<THREE.Vector2>;
-    /**
-     * Gets the current size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
-     */
-    getSize: () => THREE.Vector2;
-}
-/** Whether this component should be updated each frame. */
-export interface Updateable {
-    /** Actions that should be executed after updating the component. */
-    onAfterUpdate: Event<any>;
-    /** Actions that should be executed before updating the component. */
-    onBeforeUpdate: Event<any>;
-    /**
-     * Function used to update the state of this component each frame. For
-     * instance, a renderer component will make a render each frame.
-     */
-    update(delta?: number): void;
+export declare class SimplePlane implements Disposable, Hideable {
+    /** Event that fires when the user starts dragging a clipping plane. */
+    readonly onDraggingStarted: Event<unknown>;
+    /** Event that fires when the user stops dragging a clipping plane. */
+    readonly onDraggingEnded: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    readonly normal: THREE.Vector3;
+    readonly origin: THREE.Vector3;
+    readonly three: THREE.Plane;
+    protected readonly _helper: THREE.Object3D;
+    protected _visible: boolean;
+    protected _enabled: boolean;
+    components: Components;
+    world: World;
+    private _controlsActive;
+    private readonly _arrowBoundBox;
+    private readonly _planeMesh;
+    private readonly _controls;
+    private readonly _hiddenMaterial;
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The meshes used for raycasting */
+    get meshes(): THREE.Mesh[];
+    /** The material of the clipping plane representation. */
+    get planeMaterial(): THREE.Material | THREE.Material[];
+    /** The material of the clipping plane representation. */
+    set planeMaterial(material: THREE.Material | THREE.Material[]);
+    /** The size of the clipping plane representation. */
+    get size(): number;
+    /** Sets the size of the clipping plane representation. */
+    set size(size: number);
+    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
+    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
+    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): Promise<void>;
+    /** {@link Updateable.update} */
+    update: () => Promise<void>;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private reset;
+    protected toggleControls(state: boolean): void;
+    private newTransformControls;
+    private initializeControls;
+    private createArrowBoundingBox;
+    private changeDrag;
+    private notifyDraggingChanged;
+    private preventCameraMovement;
+    private newHelper;
+    private static newPlaneMesh;
 }
-/** Basic type to describe the progress of any kind of process. */
-export interface Progress {
-    /** The amount of things that have been done already. */
-    current: number;
-    /** The total amount of things to be done by the process. */
-    total: number;
+/// <reference types="node" />
+import * as THREE from "three";
+import { Hideable, Event, World } from "../../Types";
+import { Components } from "../../Components";
+export interface GridConfig {
+    color: THREE.Color;
+    size1: number;
+    size2: number;
+    distance: number;
 }
 /**
- * Whether this component supports create and destroy operations. This generally
- * applies for components that work with instances, such as clipping planes or
- * dimensions.
+ * An infinite grid. Created by
+ * [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper)
+ * and translated to typescript by
+ * [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
  */
-export interface Createable {
-    /** Creates a new instance of an element (e.g. a new Dimension). */
-    create: (data: any) => void;
+export declare class SimpleGrid implements Hideable, Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    world: World;
+    components: Components;
+    /** {@link Hideable.visible} */
+    get visible(): boolean;
+    /** {@link Hideable.visible} */
+    set visible(visible: boolean);
+    /** The material of the grid. */
+    get material(): THREE.ShaderMaterial;
     /**
-     * Finish the creation process of the component, successfully creating an
-     * instance of whatever the component creates.
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    endCreation?: (data: any) => void;
+    get fade(): boolean;
     /**
-     * Cancels the creation process of the component, going back to the state
-     * before starting to create.
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    cancelCreation?: (data: any) => void;
-    /** Deletes an existing instance of an element (e.g. a Dimension). */
-    delete: (data: any) => void;
+    set fade(active: boolean);
+    private readonly _grid;
+    private _fade;
+    constructor(components: Components, world: World, config: GridConfig);
+    [Symbol.dispose](): void;
+    /** {@link Component.get} */
+    get(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private setupEvents;
+    private updateZoom;
 }
 /**
- * Whether this component supports to be configured.
+ * Simple event handler by
+ * [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540).
+ * Keep in mind that:
+ * - If you want to remove it later, you might want to declare the callback as
+ * an object.
+ * - If you want to maintain the reference to 'this', you will need to declare
+ * the callback as an arrow function.
  */
-export interface Configurable<T extends Record<string, any>> {
-    /** Wether this components has been already configured. */
-    isSetup: boolean;
-    /** Use the provided configuration to setup the tool. */
-    setup: (config?: Partial<T>) => void | Promise<void>;
-    /** Fired after successfully calling {@link Configurable.setup()}  */
-    readonly onSetup: Event<any>;
-    /** Object holding the tool configuration. Is not meant to be edited directly, if you need
-     * to make changes to this object, use {@link Configurable.setup()} just after the tool is instantiated.
+export declare class Event<T> {
+    /**
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    config: Required<T>;
-}
-/**
- * An interface to make [three-mesh-bvh](https://github.com/gkjohnson/three-mesh-bvh) compatible with typescript.
- */
-export interface BVHGeometry extends THREE.BufferGeometry {
-    boundsTree: Object | undefined;
-    disposeBoundsTree: () => void;
-}
-/**
- * Whether a camera uses the Camera Controls library.
- */
-export interface CameraControllable {
-    controls: CameraControls;
+    add(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /**
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
+     */
+    remove(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => void;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
 }
 /**
  * Simple event handler by
@@ -1395,581 +1506,475 @@ export declare class AsyncEvent<T> {
     reset(): void;
     private handlers;
 }
-import { Base } from "./base";
-/**
- * Components are the building blocks of this library. Components are singleton
- * elements that contain specific functionality. For instance, the SimpleClipper
- * Component can create, delete and handle 3D clipping planes. Components must be
- * unique (they can't be instanced more than once), and have a static UUID that
- * identifies them uniquely. The can be accessed globally using the {@link Components}
- * instance.
- */
-export declare abstract class Component extends Base {
-    /**
-     * Whether this component is active or not. The behaviour can vary depending
-     * on the type of component. E.g. a disabled dimension tool will stop creating
-     * dimensions, while a disabled camera will stop moving. A disabled component
-     * will not be updated automatically each frame.
-     */
-    abstract enabled: boolean;
-}
 import * as THREE from "three";
 import CameraControls from "camera-controls";
-import { BaseWorldItem } from "./base-world-item";
-import { CameraControllable } from "./interfaces";
-export declare abstract class BaseCamera extends BaseWorldItem {
-    abstract enabled: boolean;
-    abstract three: THREE.Camera;
-    abstract controls?: CameraControls;
-    /** Whether is instance is {@link CameraControllable}. */
-    hasCameraControls: () => this is CameraControllable;
-}
-import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
-import { Components } from "../../Components";
-/**
- * Base class of the library. Useful for finding out the interfaces it implements.
- */
-export declare abstract class Base {
-    components: Components;
-    constructor(components: Components);
-    /** Whether is component is {@link Disposable}. */
-    isDisposeable: () => this is Disposable;
-    /** Whether is component is {@link Resizeable}. */
-    isResizeable: () => this is Resizeable;
-    /** Whether is component is {@link Updateable}. */
-    isUpdateable: () => this is Updateable;
-    /** Whether is component is {@link Hideable}. */
-    isHideable: () => this is Hideable;
-    /** Whether is component is {@link Configurable}. */
-    isConfigurable: () => this is Configurable<any>;
-}
-import { Base } from "./base";
-import { World } from "./world";
 import { Event } from "./event";
-import { Components } from "../../Components";
 /**
- * One of the elements that make a world. It can be either a scene, a camera
- * or a renderer.
+ * Whether this component has to be manually destroyed once you are done with
+ * it to prevent
+ * [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ * This also ensures that the DOM events created by that component will be
+ * cleaned up.
  */
-export declare abstract class BaseWorldItem extends Base {
-    readonly worlds: Map<string, World>;
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
-    }>;
-    currentWorld: World | null;
-    protected constructor(components: Components);
-}
-import * as THREE from "three";
-import { Vector2 } from "three";
-import { Event } from "./event";
-import { BaseWorldItem } from "./base-world-item";
-import { Disposable, Resizeable, Updateable } from "./interfaces";
-export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
-    abstract three: THREE.WebGLRenderer;
-    /** {@link Updateable.onBeforeUpdate} */
-    onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<undefined>;
-    readonly onResize: Event<THREE.Vector2>;
-    /**
-     * Event that fires when there has been a change to the list of clipping
-     * planes used by the active renderer.
-     */
-    readonly onClippingPlanesUpdated: Event<unknown>;
-    abstract update(delta?: number): void | Promise<void>;
-    abstract dispose(): void;
-    abstract getSize(): Vector2;
-    abstract resize(size: Vector2 | undefined): void;
-    /**
-     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this
-     * instance of the renderer.
-     */
-    clippingPlanes: THREE.Plane[];
+export interface Disposable {
     /**
-     * Forces the update of the clipping planes and all components that depend
-     * on them that are subscribed to 'onClippingPlanesUpdated'.
+     * Destroys the object from memory to prevent a
+     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
      */
-    updateClippingPlanes(): void;
+    dispose: () => void | Promise<void>;
+    /** Fired after the tool has been {@link Disposable.dispose()}  */
+    readonly onDisposed: Event<any>;
+}
+/**
+ * Whether the geometric representation of this component can be
+ * hidden or shown in the
+ * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
+ */
+export interface Hideable {
     /**
-     * Adds or removes a
-     * [clipping plane](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes)
-     * to the renderer.
+     * Whether the geometric representation of this component is
+     * currently visible or not in the
+     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
      */
-    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
-}
-import * as THREE from "three";
-import { Disposable } from "./interfaces";
-import { Event } from "./event";
-import { Components } from "../../Components";
-import { BaseWorldItem } from "./base-world-item";
-export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    abstract three: THREE.Object3D;
-    protected constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}
-import * as THREE from "three";
-import { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
-export interface World extends Disposable, Updateable {
-    meshes: Set<THREE.Mesh>;
-    scene: BaseScene;
-    camera: BaseCamera;
-    renderer: BaseRenderer | null;
-    uuid: string;
+    visible: boolean;
 }
-import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer } from "../../Types";
-import { Components } from "../../Components";
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World {
+/**
+ * Whether this component can be resized. The meaning of this can vary depending
+ * on the component: resizing a
+ * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+ * component could mean changing its resolution, whereas resizing a
+ * [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
+ */
+export interface Resizeable {
     /**
-     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh).
+     * Sets size of this component (e.g. the resolution of a
+     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+     * component.
+     */
+    resize: (size?: THREE.Vector2) => void;
+    /** Event that fires when the component has been resized. */
+    onResize: Event<THREE.Vector2>;
+    /**
+     * Gets the current size of this component (e.g. the resolution of a
+     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+     * component.
+     */
+    getSize: () => THREE.Vector2;
+}
+/** Whether this component should be updated each frame. */
+export interface Updateable {
+    /** Actions that should be executed after updating the component. */
+    onAfterUpdate: Event<any>;
+    /** Actions that should be executed before updating the component. */
+    onBeforeUpdate: Event<any>;
+    /**
+     * Function used to update the state of this component each frame. For
+     * instance, a renderer component will make a render each frame.
      */
-    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-    readonly onAfterUpdate: Event<unknown>;
-    readonly onBeforeUpdate: Event<unknown>;
-    enabled: boolean;
-    uuid: string;
-    readonly onDisposed: Event<unknown>;
-    private _scene?;
-    private _camera?;
-    private _renderer;
-    get scene(): T;
-    set scene(scene: T);
-    get camera(): U;
-    set camera(camera: U);
-    get renderer(): S | null;
-    set renderer(renderer: S | null);
-    constructor(components: Components);
     update(delta?: number): void;
-    dispose(disposeResources?: boolean): void;
 }
-/// <reference types="node" />
-import * as THREE from "three";
-import { Hideable, Event, World } from "../../Types";
-import { Components } from "../../Components";
-export interface GridConfig {
-    color: THREE.Color;
-    size1: number;
-    size2: number;
-    distance: number;
+/** Basic type to describe the progress of any kind of process. */
+export interface Progress {
+    /** The amount of things that have been done already. */
+    current: number;
+    /** The total amount of things to be done by the process. */
+    total: number;
 }
 /**
- * An infinite grid. Created by
- * [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper)
- * and translated to typescript by
- * [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ * Whether this component supports create and destroy operations. This generally
+ * applies for components that work with instances, such as clipping planes or
+ * dimensions.
  */
-export declare class SimpleGrid implements Hideable, Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    world: World;
-    components: Components;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
+export interface Createable {
+    /** Creates a new instance of an element (e.g. a new Dimension). */
+    create: (data: any) => void;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Finish the creation process of the component, successfully creating an
+     * instance of whatever the component creates.
      */
-    get fade(): boolean;
+    endCreation?: (data: any) => void;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Cancels the creation process of the component, going back to the state
+     * before starting to create.
      */
-    set fade(active: boolean);
-    private readonly _grid;
-    private _fade;
-    constructor(components: Components, world: World, config: GridConfig);
-    [Symbol.dispose](): void;
-    /** {@link Component.get} */
-    get(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
-}
-import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
-import { Components } from "../../Components";
-export interface SimpleSceneConfig {
-    directionalLight: {
-        color: THREE.Color;
-        intensity: number;
-        position: THREE.Vector3;
-    };
-    ambientLight: {
-        color: THREE.Color;
-        intensity: number;
-    };
+    cancelCreation?: (data: any) => void;
+    /** Deletes an existing instance of an element (e.g. a Dimension). */
+    delete: (data: any) => void;
 }
 /**
- * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add
- * objects hierarchically, and easily dispose them when you are finished with it.
- * @noInheritDoc
+ * Whether this component supports to be configured.
  */
-export declare class SimpleScene extends BaseScene implements Configurable<{}> {
-    /** {@link Configurable.isSetup} */
+export interface Configurable<T extends Record<string, any>> {
+    /** Wether this components has been already configured. */
     isSetup: boolean;
-    three: THREE.Scene;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<SimpleScene>;
-    config: Required<SimpleSceneConfig>;
-    constructor(components: Components);
-    /** Creates a simple and nice default set up for the scene (e.g. lighting). */
-    setup(config?: Partial<SimpleSceneConfig>): void;
+    /** Use the provided configuration to setup the tool. */
+    setup: (config?: Partial<T>) => void | Promise<void>;
+    /** Fired after successfully calling {@link Configurable.setup()}  */
+    readonly onSetup: Event<any>;
+    /** Object holding the tool configuration. Is not meant to be edited directly, if you need
+     * to make changes to this object, use {@link Configurable.setup()} just after the tool is instantiated.
+     */
+    config: Required<T>;
 }
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
-import { Components } from "../../Components";
 /**
- * A basic camera that uses
- * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
- * easily control the camera in 2D and 3D. Check out it's API to find out
- * what features it offers.
+ * An interface to make [three-mesh-bvh](https://github.com/gkjohnson/three-mesh-bvh) compatible with typescript.
  */
-export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<SimpleCamera>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<SimpleCamera>;
-    readonly onAspectUpdated: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    readonly three: THREE.PerspectiveCamera;
-    private _allControls;
-    /**
-     * The object that controls the camera. An instance of
-     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
-     * Transforming the camera directly will have no effect: you need to use this
-     * object to move, rotate, look at objects, etc.
-     */
-    get controls(): CameraControls;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
+export interface BVHGeometry extends THREE.BufferGeometry {
+    boundsTree: Object | undefined;
+    disposeBoundsTree: () => void;
+}
+/**
+ * Whether a camera uses the Camera Controls library.
+ */
+export interface CameraControllable {
+    controls: CameraControls;
+}
+import { Base } from "./base";
+/**
+ * Components are the building blocks of this library. Components are singleton
+ * elements that contain specific functionality. For instance, the SimpleClipper
+ * Component can create, delete and handle 3D clipping planes. Components must be
+ * unique (they can't be instanced more than once), and have a static UUID that
+ * identifies them uniquely. The can be accessed globally using the {@link Components}
+ * instance.
+ */
+export declare abstract class Component extends Base {
     /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
+     * Whether this component is active or not. The behaviour can vary depending
+     * on the type of component. E.g. a disabled dimension tool will stop creating
+     * dimensions, while a disabled camera will stop moving. A disabled component
+     * will not be updated automatically each frame.
      */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
+    abstract enabled: boolean;
 }
-import * as THREE from "three";
-import { BaseRenderer, Event } from "../../Types";
+import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
 import { Components } from "../../Components";
 /**
- * A basic renderer capable of rendering
- * ([Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
+ * Base class of the library. Useful for finding out the interfaces it implements.
  */
-export declare class SimpleRenderer extends BaseRenderer {
-    enabled: boolean;
-    /** The HTML container of the THREE.js canvas where the scene is rendered. */
-    container: HTMLElement;
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<HTMLElement>;
-    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Resizeable.getSize}. */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize: (size?: THREE.Vector2) => void;
-    setupEvents(active: boolean): void;
-    private resizeEvent;
-    private setupRenderer;
-    private onContextLost;
-    private onContextBack;
+export declare abstract class Base {
+    components: Components;
+    constructor(components: Components);
+    /** Whether is component is {@link Disposable}. */
+    isDisposeable: () => this is Disposable;
+    /** Whether is component is {@link Resizeable}. */
+    isResizeable: () => this is Resizeable;
+    /** Whether is component is {@link Updateable}. */
+    isUpdateable: () => this is Updateable;
+    /** Whether is component is {@link Hideable}. */
+    isHideable: () => this is Hideable;
+    /** Whether is component is {@link Configurable}. */
+    isConfigurable: () => this is Configurable<any>;
 }
-import * as THREE from "three";
+import { Base } from "./base";
+import { World } from "./world";
+import { Event } from "./event";
 import { Components } from "../../Components";
-import { AsyncEvent, Event, World } from "../../Types";
-export interface CullerRendererSettings {
-    updateInterval?: number;
-    width?: number;
-    height?: number;
-    autoUpdate?: boolean;
-}
 /**
- * A base renderer to determine visibility on screen
+ * One of the elements that make a world. It can be either a scene, a camera
+ * or a renderer.
  */
-export declare class CullerRenderer {
+export declare abstract class BaseWorldItem extends Base {
+    readonly worlds: Map<string, World>;
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
+    }>;
+    currentWorld: World | null;
+    protected constructor(components: Components);
+}
+import * as THREE from "three";
+import { Vector2 } from "three";
+import { Event } from "./event";
+import { BaseWorldItem } from "./base-world-item";
+import { Disposable, Resizeable, Updateable } from "./interfaces";
+export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
+    abstract three: THREE.WebGLRenderer;
+    /** {@link Updateable.onBeforeUpdate} */
+    onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onAfterUpdate} */
+    onBeforeUpdate: Event<unknown>;
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    readonly onDisposed: Event<undefined>;
+    readonly onResize: Event<THREE.Vector2>;
     /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
+     * Event that fires when there has been a change to the list of clipping
+     * planes used by the active renderer.
      */
-    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    readonly onClippingPlanesUpdated: Event<unknown>;
+    abstract update(delta?: number): void | Promise<void>;
+    abstract dispose(): void;
+    abstract getSize(): Vector2;
+    abstract resize(size: Vector2 | undefined): void;
     /**
-     * Needs to check whether there are objects that need to be hidden or shown.
-     * You can bind this to the camera movement, to a certain interval, etc.
+     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this
+     * instance of the renderer.
      */
-    needsUpdate: boolean;
+    clippingPlanes: THREE.Plane[];
     /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
+     * Forces the update of the clipping planes and all components that depend
+     * on them that are subscribed to 'onClippingPlanesUpdated'.
      */
-    renderDebugFrame: boolean;
-    components: Components;
-    readonly world: World;
-    readonly renderer: THREE.WebGLRenderer;
-    protected autoUpdate: boolean;
-    protected updateInterval: number;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _width;
-    private _height;
-    private _availableColor;
-    private readonly renderTarget;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    updateClippingPlanes(): void;
     /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
+     * Adds or removes a
+     * [clipping plane](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes)
+     * to the renderer.
      */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-    private applySettings;
-}
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
-import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World } from "../../Types";
-/**
- * A renderer to determine a mesh visibility on screen
- */
-export declare class MeshCullerRenderer extends CullerRenderer {
-    threshold: number;
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
-    }>;
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    isProcessing: boolean;
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private _intervalID;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    dispose(): void;
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
+    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }
 import * as THREE from "three";
-import { Hideable, Disposable, Event, World } from "../../Types";
+import { Disposable } from "./interfaces";
+import { Event } from "./event";
 import { Components } from "../../Components";
-/**
- * Each of the planes created by {@link SimpleClipper}.
- */
-export declare class SimplePlane implements Disposable, Hideable {
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onDraggingStarted: Event<unknown>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onDraggingEnded: Event<unknown>;
+import { BaseWorldItem } from "./base-world-item";
+export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    readonly normal: THREE.Vector3;
-    readonly origin: THREE.Vector3;
-    readonly three: THREE.Plane;
-    protected readonly _helper: THREE.Object3D;
-    protected _visible: boolean;
-    protected _enabled: boolean;
-    components: Components;
-    world: World;
-    private _controlsActive;
-    private readonly _arrowBoundBox;
-    private readonly _planeMesh;
-    private readonly _controls;
-    private readonly _hiddenMaterial;
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The meshes used for raycasting */
-    get meshes(): THREE.Mesh[];
-    /** The material of the clipping plane representation. */
-    get planeMaterial(): THREE.Material | THREE.Material[];
-    /** The material of the clipping plane representation. */
-    set planeMaterial(material: THREE.Material | THREE.Material[]);
-    /** The size of the clipping plane representation. */
-    get size(): number;
-    /** Sets the size of the clipping plane representation. */
-    set size(size: number);
-    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
-    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
-    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): Promise<void>;
-    /** {@link Updateable.update} */
-    update: () => Promise<void>;
+    abstract three: THREE.Object3D;
+    protected constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    private reset;
-    protected toggleControls(state: boolean): void;
-    private newTransformControls;
-    private initializeControls;
-    private createArrowBoundingBox;
-    private changeDrag;
-    private notifyDraggingChanged;
-    private preventCameraMovement;
-    private newHelper;
-    private static newPlaneMesh;
 }
-import { IfcFragmentSettings } from "../../FragmentIfcLoader/src";
-/** Configuration of the IFC-fragment streaming. */
-export declare class IfcStreamingSettings extends IfcFragmentSettings {
-    minGeometrySize: number;
-    minAssetsSize: number;
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { BaseWorldItem } from "./base-world-item";
+import { CameraControllable } from "./interfaces";
+export declare abstract class BaseCamera extends BaseWorldItem {
+    abstract enabled: boolean;
+    abstract three: THREE.Camera;
+    abstract controls?: CameraControls;
+    /** Whether is instance is {@link CameraControllable}. */
+    hasCameraControls: () => this is CameraControllable;
 }
-/** Configuration of the IFC-fragment streaming. */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
-    propertiesSize: number;
+import * as THREE from "three";
+import { BaseScene } from "./base-scene";
+import { BaseCamera } from "./base-camera";
+import { BaseRenderer } from "./base-renderer";
+import { Updateable, Disposable } from "./interfaces";
+export interface World extends Disposable, Updateable {
+    meshes: Set<THREE.Mesh>;
+    scene: BaseScene;
+    camera: BaseCamera;
+    renderer: BaseRenderer | null;
+    uuid: string;
 }
 import * as THREE from "three";
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-export declare class CivilReader {
-    defLineMat: THREE.LineBasicMaterial;
-    read(webIfc: WEBIFC.IfcAPI): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    get(civilItems: any): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    private getCurves;
+import { Components } from "../../Components";
+import { AsyncEvent, Event, World } from "../../Types";
+export interface CullerRendererSettings {
+    updateInterval?: number;
+    width?: number;
+    height?: number;
+    autoUpdate?: boolean;
 }
-import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../../core";
-import { PropertiesStreamingSettings } from "./streaming-settings";
-export declare class FragmentPropsStreamConverter extends Component implements Disposable {
-    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
-    onPropertiesStreamed: AsyncEvent<{
-        type: number;
-        data: {
-            [id: number]: any;
-        };
-    }>;
-    onProgress: AsyncEvent<number>;
-    onIndicesStreamed: AsyncEvent<number[][]>;
+/**
+ * A base renderer to determine visibility on screen
+ */
+export declare class CullerRenderer {
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
+    /**
+     * Fires after making the visibility check to the meshes. It lists the
+     * meshes that are currently visible, and the ones that were visible
+     * just before but not anymore.
+     */
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
+    /** {@link Component.enabled} */
     enabled: boolean;
-    settings: PropertiesStreamingSettings;
-    webIfc: WEBIFC.IfcAPI;
-    dispose(): Promise<void>;
-    streamFromBuffer(data: Uint8Array): Promise<void>;
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllProperties;
-    private getIndices;
-    private cleanUp;
-}
-import * as WEBIFC from "web-ifc";
-/** Configuration of the IFC-fragment conversion. */
-export declare class IfcFragmentSettings {
-    /** Whether to extract the IFC properties into a JSON. */
-    includeProperties: boolean;
     /**
-     * Generate the geometry for categories that are not included by default,
-     * like IFCSPACE.
+     * Needs to check whether there are objects that need to be hidden or shown.
+     * You can bind this to the camera movement, to a certain interval, etc.
      */
-    optionalCategories: number[];
-    /** Whether to use the coordination data coming from the IFC files. */
-    coordinate: boolean;
-    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    wasm: {
-        path: string;
-        absolute: boolean;
-        logLevel?: WEBIFC.LogLevel;
+    needsUpdate: boolean;
+    /**
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
+     */
+    renderDebugFrame: boolean;
+    components: Components;
+    readonly world: World;
+    readonly renderer: THREE.WebGLRenderer;
+    protected autoUpdate: boolean;
+    protected updateInterval: number;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _width;
+    private _height;
+    private _availableColor;
+    private readonly renderTarget;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    updateVisibility: (force?: boolean) => Promise<void>;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
     };
-    /** List of categories that won't be converted to fragments. */
-    excludedCategories: Set<number>;
-    /** Whether to save the absolute location of all IFC items. */
-    saveLocations: boolean;
-    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    webIfc: WEBIFC.LoaderSettings;
-    autoSetWasm: boolean;
-    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
+    private applySettings;
 }
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    get(webIfc: WEBIFC.IfcAPI, type: number): string;
+import { NavigationMode } from "./types";
+/**
+ * A {@link NavigationMode} that allows first person navigation,
+ * simulating FPS video games.
+ */
+export declare class FirstPersonMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "FirstPerson";
+    constructor(camera: any);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
 }
-export interface StreamedGeometries {
-    [id: number]: {
-        boundingBox: Float32Array;
-        hasHoles: boolean;
-        geometryFile?: string;
-    };
+import * as THREE from "three";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
+import { Components } from "../../Components";
+import { Event, World } from "../../Types";
+/**
+ * A renderer to determine a mesh visibility on screen
+ */
+export declare class MeshCullerRenderer extends CullerRenderer {
+    threshold: number;
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    isProcessing: boolean;
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private _intervalID;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    dispose(): void;
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
 }
-export interface StreamedAsset {
-    id: number;
-    geometries: {
-        geometryID: number;
-        transformation: number[];
-        color: number[];
-    }[];
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
+import { NavigationMode } from "./types";
+/**
+ * A {@link NavigationMode} that allows 3D navigation and panning
+ * like in many 3D and CAD softwares.
+ */
+export declare class OrbitMode implements NavigationMode {
+    camera: any;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: any);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
+}
+import { NavigationMode } from "./types";
+/**
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D,
+ * like many BIM tools.
+ */
+export declare class PlanMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Plan";
+    private mouseAction1?;
+    private mouseAction2?;
+    private mouseInitialized;
+    private readonly defaultAzimuthSpeed;
+    private readonly defaultPolarSpeed;
+    constructor(camera: any);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
 }
-import * as WEBIFC from "web-ifc";
 import * as THREE from "three";
-export declare class Units {
-    factor: number;
-    complement: number;
-    apply(matrix: THREE.Matrix4): void;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    private getLengthUnits;
-    private getScaleMatrix;
+import { CameraProjection } from "./types";
+import { Event } from "../../../core";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
+    /**
+     * Event that fires when the {@link CameraProjection} changes.
+     */
+    readonly onChanged: Event<THREE.Camera>;
+    current: CameraProjection;
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    private _component;
+    private _previousDistance;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    constructor(camera: OrthoPerspectiveCamera);
+    /**
+     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     *
+     * @param projection - the new projection to set. If it is the current projection,
+     * it will have no effect.
+     */
+    set(projection: CameraProjection): Promise<void>;
+    /**
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
+     */
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getDims;
+    private setupOrthoCamera;
+    private getDistance;
+    private setPerspectiveCamera;
+}
+/**
+ * The projection system of the camera.
+ */
+export type CameraProjection = "Perspective" | "Orthographic";
+/**
+ * The extensible list of supported navigation modes.
+ */
+export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
+/**
+ * An object that determines the behavior of the camera controls
+ * and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ */
+export interface NavigationMode {
+    /** The unique ID of this navigation mode. */
+    id: NavModeID;
+    /**
+     * Enable or disable this navigation mode.
+     * When a new navigation mode is enabled, the previous navigation mode
+     * must be disabled.
+     *
+     * @param active - whether to enable or disable this mode.
+     * @param options - any additional data required to enable or disable it.
+     * */
+    set: (active: boolean, options?: any) => void;
+    /** Whether this navigation mode is active or not. */
+    enabled: boolean;
+}
+import { BufferGeometry } from "three";
+import * as THREE from "three";
+export declare class TransformHelper {
+    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
 }
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
@@ -1995,11 +2000,6 @@ export type InverseAttributes = [
     "ContainsElements"
 ];
 export type InverseAttribute = InverseAttributes[number];
-import { BufferGeometry } from "three";
-import * as THREE from "three";
-export declare class TransformHelper {
-    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
-}
 export type QueryConditions = "is" | "includes" | "startsWith" | "endsWith" | "matches";
 export type ConditionFunctions = {
     [queryCondition in QueryConditions]: (leftValue: string | boolean | number, rightValue: string | boolean | number) => boolean;