@thatopen/components 2.1.26 → 2.1.27

package/dist/namespace.d.ts

@@ -1,49 +1,4 @@
 declare namespace OBC {
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
-/**
- * A tool to safely remove meshes, geometries, materials and other items 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;
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * Return the UUIDs of all disposed 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 { Component, Disposable, Event } from "../Types";
 /**
  * The entry point of the Components library. It can create, delete and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
@@ -52,7 +7,7 @@ export declare class Components implements Disposable {
     /**
      * The version of the @thatopen/components library.
      */
-    static readonly release = "2.1.26";
+    static readonly release = "2.1.27";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
     /**
@@ -179,6 +134,93 @@ export declare class ShadowedScene extends SimpleScene implements Disposable {
     updateShadows(): Promise<void>;
     private recomputeShadows;
 }
+import { Component, Disposable, World, Event } from "../Types";
+import { SimpleRaycaster } from "./src";
+import { Components } from "../Components";
+/**
+ * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
+ */
+export declare class Raycasters extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * A Map that stores raycasters for each world.
+     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     */
+    list: Map<string, SimpleRaycaster>;
+    /** {@link Disposable.onDisposed} */
+    onDisposed: Event<unknown>;
+    constructor(components: Components);
+    /**
+     * Retrieves a SimpleRaycaster instance for the given world.
+     * If a SimpleRaycaster instance already exists for the world, it will be returned.
+     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
+     *
+     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
+     * @returns The SimpleRaycaster instance for the given world.
+     */
+    get(world: World): SimpleRaycaster;
+    /**
+     * Deletes the SimpleRaycaster instance associated with the given world.
+     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
+     *
+     * @param world - The world for which to delete the SimpleRaycaster instance.
+     * @returns {void}
+     */
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+}
+import * as THREE from "three";
+import { Components } from "../Components";
+import { Component } from "../Types";
+/**
+ * A tool to safely remove meshes, geometries, materials and other items 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;
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
+    constructor(components: Components);
+    /**
+     * Return the UUIDs of all disposed 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 { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
 import { Components } from "../Components";
 import { SimpleWorld } from "./src";
@@ -295,96 +337,188 @@ export declare class Grids extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
-import { Components } from "../Components";
+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 function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
+import * as THREE from "three";
+import { Component, Components, Disposable, Event, World } from "../core";
 /**
- * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
+ * Configuration interface for the VertexPicker component.
  */
-export declare class Raycasters extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
-    /** {@link Component.enabled} */
-    enabled: boolean;
+export interface VertexPickerConfig {
     /**
-     * A Map that stores raycasters for each world.
-     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     * If true, only vertices will be picked, not the closest point on the face.
      */
-    list: Map<string, SimpleRaycaster>;
-    /** {@link Disposable.onDisposed} */
-    onDisposed: Event<unknown>;
-    constructor(components: Components);
+    showOnlyVertex: boolean;
     /**
-     * Retrieves a SimpleRaycaster instance for the given world.
-     * If a SimpleRaycaster instance already exists for the world, it will be returned.
-     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
-     *
-     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
-     * @returns The SimpleRaycaster instance for the given world.
+     * The maximum distance for snapping to a vertex.
      */
-    get(world: World): SimpleRaycaster;
+    snapDistance: number;
     /**
-     * Deletes the SimpleRaycaster instance associated with the given world.
-     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
-     *
-     * @param world - The world for which to delete the SimpleRaycaster instance.
-     * @returns {void}
+     * The HTML element to use for previewing the picked vertex.
      */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    previewElement: HTMLElement;
 }
-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, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
- *
- * @param components - the instance of {@link Components} used.
- * E.g. {@link SimplePlane}.
+ * A class that provides functionality for picking vertices in a 3D scene.
  */
-export declare class Clipper extends Component implements Createable, Disposable, Hideable {
+export declare class VertexPicker extends Component implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
      */
-    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
-    /** 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 onVertexFound: Event<THREE.Vector3>;
     /**
-     * Event that fires when the user starts creating a clipping plane.
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
      */
-    readonly onBeforeCreate: Event<unknown>;
+    readonly onVertexLost: Event<THREE.Vector3>;
     /**
-     * Event that fires when the user cancels the creation of a clipping plane.
+     * An event that is triggered when the picker is enabled or disabled
      */
-    readonly onBeforeCancel: Event<unknown>;
+    readonly onEnabled: Event<boolean>;
     /**
-     * Event that fires after the user cancels the creation of a clipping plane.
+     * A reference to the Components instance associated with this VertexPicker.
      */
-    readonly onAfterCancel: Event<unknown>;
+    components: Components;
     /**
-     * Event that fires when the user starts deleting a clipping plane.
+     * A reference to the working plane used for vertex picking.
+     * This plane is used to determine which vertices are considered valid for picking.
+     * If this value is null, all vertices are considered valid.
      */
-    readonly onBeforeDelete: Event<unknown>;
+    workingPlane: THREE.Plane | null;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
     /**
-     * Event that fires after a clipping plane has been created.
-     * @param plane - The newly created clipping plane.
+     * Sets the enabled state of the VertexPicker.
+     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
+     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
+     *
+     * @param value - The new enabled state.
      */
-    readonly onAfterCreate: Event<SimplePlane>;
+    set enabled(value: boolean);
     /**
-     * Event that fires after a clipping plane has been deleted.
-     * @param plane - The deleted clipping plane.
+     * Gets the current enabled state of the VertexPicker.
+     *
+     * @returns The current enabled state.
      */
-    readonly onAfterDelete: Event<SimplePlane>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    get enabled(): boolean;
+    /**
+     * Sets the configuration for the VertexPicker component.
+     *
+     * @param value - A Partial object containing the configuration properties to update.
+     * The properties not provided in the value object will retain their current values.
+     *
+     * @example
+     * '''typescript
+     * vertexPicker.config = {
+     *   snapDistance: 0.5,
+     *   showOnlyVertex: true,
+     * };
+     * '''
+     */
+    set config(value: Partial<VertexPickerConfig>);
+    /**
+     * Gets the current configuration for the VertexPicker component.
+     *
+     * @returns A copy of the current VertexPickerConfig object.
+     *
+     * @example
+     * '''typescript
+     * const currentConfig = vertexPicker.config;
+     * console.log(currentConfig.snapDistance); // Output: 0.25
+     * '''
+     */
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
+     *
+     * @param world - The World instance to use for raycasting.
+     *
+     * @returns The current picked point, or null if no point is picked.
+     *
+     * @remarks
+     * This method checks if the VertexPicker is enabled. If not, it returns the current picked point.
+     * If enabled, it performs raycasting to find the closest intersecting object.
+     * It then determines the closest vertex or point on the face, based on the configuration settings.
+     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
+     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
+     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
+     */
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+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, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
+ *
+ * @param components - the instance of {@link Components} used.
+ * E.g. {@link SimplePlane}.
+ */
+export declare class Clipper extends Component implements Createable, Disposable, Hideable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
+    /** 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>;
+    /**
+     * Event that fires when the user starts creating a clipping plane.
+     */
+    readonly onBeforeCreate: Event<unknown>;
+    /**
+     * Event that fires when the user cancels the creation of a clipping plane.
+     */
+    readonly onBeforeCancel: Event<unknown>;
+    /**
+     * Event that fires after the user cancels the creation of a clipping plane.
+     */
+    readonly onAfterCancel: Event<unknown>;
+    /**
+     * Event that fires when the user starts deleting a clipping plane.
+     */
+    readonly onBeforeDelete: Event<unknown>;
+    /**
+     * Event that fires after a clipping plane has been created.
+     * @param plane - The newly created clipping plane.
+     */
+    readonly onAfterCreate: Event<SimplePlane>;
+    /**
+     * Event that fires after a clipping plane has been deleted.
+     * @param plane - The deleted clipping plane.
+     */
+    readonly onAfterDelete: Event<SimplePlane>;
+    /** {@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
@@ -637,12 +771,110 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
     private setOrthoPerspCameraAspect;
 }
 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 { Component, Components } from "../../core";
+/**
+ * Represents an edge measurement result.
+ */
+export interface MeasureEdge {
+    /**
+     * The distance between the two points of the edge.
+     */
+    distance: number;
+    /**
+     * The two points that define the edge.
+     */
+    points: THREE.Vector3[];
+}
+/**
+ * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
+ */
+export declare class MeasurementUtils extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static uuid: string;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Utility method to calculate the distance from a point to a line segment.
+     *
+     * @param point - The point from which to calculate the distance.
+     * @param lineStart - The start point of the line segment.
+     * @param lineEnd - The end point of the line segment.
+     * @param clamp - If true, the distance will be clamped to the line segment's length.
+     * @returns The distance from the point to the line segment.
+     */
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    /**
+     * Method to get the face of a mesh that contains a given triangle index.
+     * It also returns the edges of the found face and their indices.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param triangleIndex - The index of the triangle within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
+     */
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    /**
+     * Method to get the vertices and normal of a mesh face at a given index.
+     * It also applies instance transformation if provided.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param faceIndex - The index of the face within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the vertices and normal of the face.
+     * @throws Will throw an error if the geometry is not indexed.
+     */
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    /**
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
+     *
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
+     */
+    round(vector: THREE.Vector3): void;
+    /**
+     * Calculates the volume of a set of fragments.
+     *
+     * @param frags - A map of fragment IDs to their corresponding item IDs.
+     * @returns The total volume of the fragments and the bounding sphere.
+     *
+     * @remarks
+     * This method creates a set of instanced meshes from the given fragments and item IDs.
+     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
+     *
+     * @throws Will throw an error if the geometry of the meshes is not indexed.
+     * @throws Will throw an error if the fragment manager is not available.
+     */
+    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    /**
+     * Calculates the total volume of a set of meshes.
+     *
+     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
+     * @returns The total volume of the meshes and the bounding sphere.
+     *
+     * @remarks
+     * This method calculates the volume of each mesh in the provided array and returns the total volume
+     * and its bounding sphere.
+     *
+     */
+    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
+    private getFaceData;
+    private getVolumeOfMesh;
+    private getSignedVolumeOfTriangle;
+}
 import * as WEBIFC from "web-ifc";
 import * as FRAG from "@thatopen/fragments";
 import { Component, Components } from "../../core";
@@ -668,54 +900,228 @@ export declare class IfcJsonExporter extends Component {
      */
     export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
 import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Disposable, Event, Components } from "../../core";
-/**
- * Types for boolean properties in IFC schema.
- */
-export type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
-/**
- * Types for string properties in IFC schema.
- */
-export type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
-/**
- * Types for numeric properties in IFC schema.
- */
-export type NumericPropTypes = "IfcInteger" | "IfcReal";
-/**
- * Interface representing a map of changed entities in a model. The keys are model UUIDs, and the values are sets of express IDs of changed entities.
- */
-export interface ChangeMap {
-    [modelID: string]: Set<number>;
-}
-/**
- * Interface representing a map of attribute listeners. The keys are model UUIDs, and the values are objects with express IDs as keys, and objects with attribute names as keys, and Event objects as values.
- */
-export interface AttributeListener {
-    [modelID: string]: {
-        [expressID: number]: {
-            [attributeName: string]: Event<String | Boolean | Number>;
-        };
-    };
-}
+import { Disposable, Event, Component, Components } from "../../core";
+import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
+export type { InverseAttribute, RelationsMap } from "./src/types";
 /**
- * Component to manage and edit properties and Psets in IFC files.
+ * Indexer component 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. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
  */
-export declare class IfcPropertiesManager extends Component implements Disposable {
+export declare class IfcRelationsIndexer extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
     /**
-     * Event triggered when a file is requested for export.
+     * Event triggered when relations for a model have been indexed.
+     * This event provides the model's UUID and the relations map generated for that model.
+     *
+     * @property {string} modelID - The UUID of the model for which relations have been indexed.
+     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
+     * 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.
      */
-    readonly onRequestFile: Event<unknown>;
-    /**
+    readonly onRelationsIndexed: Event<{
+        modelID: string;
+        relationsMap: RelationsMap;
+    }>;
+    /**
+     * 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;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    private _relToAttributesMap;
+    private _inverseAttributes;
+    private _ifcRels;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    private indexRelations;
+    private getAttributeIndex;
+    /**
+     * 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.
+     *
+     * @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;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Retrieves the entities within a given model that have a specific relation with a given entity.
+     *
+     * @param model - The BIM model to search for related entities.
+     * @param inv - The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
+     * @param expressID - The expressID of the entity within the model.
+     *
+     * @returns A 'Set' with the expressIDs of the entities that have the specified relation with the given entity.
+     *
+     * @throws An error if the model relations are not indexed or if the inverse attribute name is invalid.
+     */
+    getEntitiesWithRelation(model: FragmentsGroup, inv: InverseAttribute, expressID: number): Set<number>;
+    /**
+     * Adds relations between an entity and other entities in a BIM model.
+     *
+     * @param model - The BIM model to which the relations will be added.
+     * @param expressID - The expressID of the entity within the model.
+     * @param relationName - The IFC schema inverse attribute of the relation to add (e.g., "IsDefinedBy", "ContainsElements").
+     * @param relIDs - The expressIDs of the related entities within the model.
+     *
+     * @throws An error if the relation name is not a valid relation name.
+     */
+    addEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute, ...relIDs: number[]): void;
+    /**
+     * Gets the children of the given element recursively. E.g. in a model with project - site - building - storeys - rooms, passing a storey will include all its children and the children of the rooms contained in it.
+     *
+     * @param model The BIM model whose children to get.
+     * @param expressID The expressID of the item whose children to get.
+     * @param found An optional parameter that includes a set of expressIDs where the found element IDs will be added.
+     *
+     * @returns A 'Set' with the expressIDs of the found items.
+     */
+    getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
+}
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Disposable, Event, Components } from "../../core";
+/**
+ * Types for boolean properties in IFC schema.
+ */
+export type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
+/**
+ * Types for string properties in IFC schema.
+ */
+export type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
+/**
+ * Types for numeric properties in IFC schema.
+ */
+export type NumericPropTypes = "IfcInteger" | "IfcReal";
+/**
+ * Interface representing a map of changed entities in a model. The keys are model UUIDs, and the values are sets of express IDs of changed entities.
+ */
+export interface ChangeMap {
+    [modelID: string]: Set<number>;
+}
+/**
+ * Interface representing a map of attribute listeners. The keys are model UUIDs, and the values are objects with express IDs as keys, and objects with attribute names as keys, and Event objects as values.
+ */
+export interface AttributeListener {
+    [modelID: string]: {
+        [expressID: number]: {
+            [attributeName: string]: Event<String | Boolean | Number>;
+        };
+    };
+}
+/**
+ * Component to manage and edit properties and Psets in IFC files.
+ */
+export declare class IfcPropertiesManager extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * Event triggered when a file is requested for export.
+     */
+    readonly onRequestFile: Event<unknown>;
+    /**
      * ArrayBuffer containing the IFC data to be exported.
      */
     ifcToExport: ArrayBuffer | null;
@@ -925,296 +1331,28 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
     private registerChange;
     private newSingleProperty;
 }
-import * as WEBIFC from "web-ifc";
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
 import { FragmentsGroup } from "@thatopen/fragments";
-import { Disposable, Event, Component, Components } from "../../core";
-import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
-export type { InverseAttribute, RelationsMap } from "./src/types";
+import { Component, Components, Disposable, Event } from "../../core";
 /**
- * Indexer component 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. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
+ * 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. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/BoundingBoxer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/BoundingBoxer).
  */
-export declare class IfcRelationsIndexer extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Event triggered when relations for a model have been indexed.
-     * This event provides the model's UUID and the relations map generated for that model.
-     *
-     * @property {string} modelID - The UUID of the model for which relations have been indexed.
-     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
-     * 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.
-     */
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
-    /**
-     * 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;
+export declare class BoundingBoxer extends Component implements Disposable {
+    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
     /** {@link Component.enabled} */
     enabled: boolean;
-    private _relToAttributesMap;
-    private _inverseAttributes;
-    private _ifcRels;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    private _absoluteMin;
+    private _absoluteMax;
+    private _meshes;
     constructor(components: Components);
-    private onFragmentsDisposed;
-    private indexRelations;
-    private getAttributeIndex;
     /**
-     * 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.
+     * A static method to calculate the dimensions of a given bounding box.
      *
-     * @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.
-     *
-     * @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;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Adds relations between an entity and other entities in a BIM model.
-     *
-     * @param model - The BIM model to which the relations will be added.
-     * @param expressID - The expressID of the entity within the model.
-     * @param relationName - The IFC schema inverse attribute of the relation to add (e.g., "IsDefinedBy", "ContainsElements").
-     * @param relIDs - The expressIDs of the related entities within the model.
-     *
-     * @throws An error if the relation name is not a valid relation name.
-     */
-    addEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute, ...relIDs: number[]): void;
-    /**
-     * Gets the children of the given element recursively. E.g. in a model with project - site - building - storeys - rooms, passing a storey will include all its children and the children of the rooms contained in it.
-     *
-     * @param model The BIM model whose children to get.
-     * @param expressID The expressID of the item whose children to get.
-     * @param found An optional parameter that includes a set of expressIDs where the found element IDs will be added.
-     *
-     * @returns A 'Set' with the expressIDs of the found items.
-     */
-    getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
-}
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Represents an edge measurement result.
- */
-export interface MeasureEdge {
-    /**
-     * The distance between the two points of the edge.
-     */
-    distance: number;
-    /**
-     * The two points that define the edge.
-     */
-    points: THREE.Vector3[];
-}
-/**
- * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
- */
-export declare class MeasurementUtils extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Utility method to calculate the distance from a point to a line segment.
-     *
-     * @param point - The point from which to calculate the distance.
-     * @param lineStart - The start point of the line segment.
-     * @param lineEnd - The end point of the line segment.
-     * @param clamp - If true, the distance will be clamped to the line segment's length.
-     * @returns The distance from the point to the line segment.
-     */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    /**
-     * Method to get the face of a mesh that contains a given triangle index.
-     * It also returns the edges of the found face and their indices.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param triangleIndex - The index of the triangle within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
-     */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
-     */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
-     *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
-     */
-    round(vector: THREE.Vector3): void;
-    /**
-     * Calculates the volume of a set of fragments.
-     *
-     * @param frags - A map of fragment IDs to their corresponding item IDs.
-     * @returns The total volume of the fragments and the bounding sphere.
-     *
-     * @remarks
-     * This method creates a set of instanced meshes from the given fragments and item IDs.
-     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
-     *
-     * @throws Will throw an error if the geometry of the meshes is not indexed.
-     * @throws Will throw an error if the fragment manager is not available.
-     */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
-    /**
-     * Calculates the total volume of a set of meshes.
-     *
-     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
-     * @returns The total volume of the meshes and the bounding sphere.
-     *
-     * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
-     *
-     */
-    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
-    private getFaceData;
-    private getVolumeOfMesh;
-    private getSignedVolumeOfTriangle;
-}
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Components, Disposable, Event } from "../../core";
-/**
- * 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. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/BoundingBoxer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/BoundingBoxer).
- */
-export declare class BoundingBoxer extends Component implements Disposable {
-    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    private _absoluteMin;
-    private _absoluteMax;
-    private _meshes;
-    constructor(components: Components);
-    /**
-     * A static method to calculate the dimensions of a given bounding box.
-     *
-     * @param bbox - The bounding box to calculate the dimensions for.
-     * @returns An object containing the width, height, depth, and center of the bounding box.
+     * @param bbox - The bounding box to calculate the dimensions for.
+     * @returns An object containing the width, height, depth, and center of the bounding box.
      */
     static getDimensions(bbox: THREE.Box3): {
         width: number;
@@ -1663,32 +1801,147 @@ export declare class Hider extends Component {
     isolate(items: FRAGS.FragmentIdMap): void;
     private updateCulledVisibility;
 }
-import { Fragment, FragmentsGroup } from "@thatopen/fragments";
-import * as THREE from "three";
+import * as WEBIFC from "web-ifc";
 import * as FRAGS from "@thatopen/fragments";
-import { Component, Components, Event, Disposable, DataMap } from "../../core";
-import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
 /**
- * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
+ * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
  */
-export declare class FragmentsManager extends Component implements Disposable {
+export declare class IfcLoader extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
+    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    readonly onDisposed: Event<string>;
     /**
-     * Event triggered when fragments are loaded.
+     * An event triggered when the IFC file starts loading.
      */
-    readonly onFragmentsLoaded: Event<FragmentsGroup>;
+    readonly onIfcStartedLoading: Event<void>;
     /**
-     * Event triggered when fragments are disposed.
+     * An event triggered when the setup process is completed.
      */
-    readonly onFragmentsDisposed: Event<{
-        groupID: string;
-        fragmentIDs: string[];
+    readonly onSetup: Event<void>;
+    /**
+     * The settings for the IfcLoader.
+     * It includes options for excluding categories, setting WASM paths, and more.
+     */
+    settings: IfcFragmentSettings;
+    /**
+     * The instance of the Web-IFC library used for handling IFC data.
+     */
+    webIfc: WEBIFC.IfcAPI;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    private _material;
+    private _spatialTree;
+    private _metaData;
+    private _fragmentInstances;
+    private _civil;
+    private _visitedFragments;
+    private _materialT;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets up the IfcLoader component with the provided configuration.
+     *
+     * @param config - Optional configuration settings for the IfcLoader.
+     * If not provided, the existing settings will be used.
+     *
+     * @returns A Promise that resolves when the setup process is completed.
+     *
+     * @remarks
+     * If the 'autoSetWasm' option is enabled in the configuration,
+     * the method will automatically set the WASM paths for the Web-IFC library.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = new IfcLoader(components);
+     * await ifcLoader.setup({ autoSetWasm: true });
+     * '''
+     */
+    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    /**
+     * Loads an IFC file and processes it for 3D visualization.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     * @param coordinate - Optional boolean indicating whether to coordinate the loaded IFC data. Default is true.
+     *
+     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * const group = await ifcLoader.load(ifcData);
+     * '''
+     */
+    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
+    /**
+     * Reads an IFC file and initializes the Web-IFC library.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     *
+     * @returns A Promise that resolves when the IFC file is opened and initialized.
+     *
+     * @remarks
+     * This method sets the WASM path and initializes the Web-IFC library based on the provided settings.
+     * It also opens the IFC model using the provided data and settings.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * await ifcLoader.readIfcFile(ifcData);
+     * '''
+     */
+    readIfcFile(data: Uint8Array): Promise<number>;
+    /**
+     * Cleans up the IfcLoader component by resetting the Web-IFC library,
+     * clearing the visited fragments and fragment instances maps, and creating a new instance of the Web-IFC library.
+     *
+     * @remarks
+     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * ifcLoader.cleanUp();
+     * '''
+     */
+    cleanUp(): void;
+    private getAllGeometries;
+    private getMesh;
+    private getGeometry;
+    private autoSetWasm;
+}
+import { Fragment, FragmentsGroup } from "@thatopen/fragments";
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components, Event, Disposable, DataMap } from "../../core";
+import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
+/**
+ * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
+ */
+export declare class FragmentsManager extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Event triggered when fragments are loaded.
+     */
+    readonly onFragmentsLoaded: Event<FragmentsGroup>;
+    /**
+     * Event triggered when fragments are disposed.
+     */
+    readonly onFragmentsDisposed: Event<{
+        groupID: string;
+        fragmentIDs: string[];
     }>;
     /**
      * DataMap containing all loaded fragments.
@@ -1800,121 +2053,6 @@ export declare class FragmentsManager extends Component implements Disposable {
     clone(model: FRAGS.FragmentsGroup, items?: FRAGS.FragmentIdMap): FragmentsGroup;
 }
 import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
-/**
- * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
- */
-export declare class IfcLoader extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * An event triggered when the IFC file starts loading.
-     */
-    readonly onIfcStartedLoading: Event<void>;
-    /**
-     * An event triggered when the setup process is completed.
-     */
-    readonly onSetup: Event<void>;
-    /**
-     * The settings for the IfcLoader.
-     * It includes options for excluding categories, setting WASM paths, and more.
-     */
-    settings: IfcFragmentSettings;
-    /**
-     * The instance of the Web-IFC library used for handling IFC data.
-     */
-    webIfc: WEBIFC.IfcAPI;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _material;
-    private _spatialTree;
-    private _metaData;
-    private _fragmentInstances;
-    private _civil;
-    private _visitedFragments;
-    private _materialT;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets up the IfcLoader component with the provided configuration.
-     *
-     * @param config - Optional configuration settings for the IfcLoader.
-     * If not provided, the existing settings will be used.
-     *
-     * @returns A Promise that resolves when the setup process is completed.
-     *
-     * @remarks
-     * If the 'autoSetWasm' option is enabled in the configuration,
-     * the method will automatically set the WASM paths for the Web-IFC library.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = new IfcLoader(components);
-     * await ifcLoader.setup({ autoSetWasm: true });
-     * '''
-     */
-    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
-    /**
-     * Loads an IFC file and processes it for 3D visualization.
-     *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @param coordinate - Optional boolean indicating whether to coordinate the loaded IFC data. Default is true.
-     *
-     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * const group = await ifcLoader.load(ifcData);
-     * '''
-     */
-    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
-    /**
-     * Reads an IFC file and initializes the Web-IFC library.
-     *
-     * @param data - The Uint8Array containing the IFC file data.
-     *
-     * @returns A Promise that resolves when the IFC file is opened and initialized.
-     *
-     * @remarks
-     * This method sets the WASM path and initializes the Web-IFC library based on the provided settings.
-     * It also opens the IFC model using the provided data and settings.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * await ifcLoader.readIfcFile(ifcData);
-     * '''
-     */
-    readIfcFile(data: Uint8Array): Promise<number>;
-    /**
-     * Cleans up the IfcLoader component by resetting the Web-IFC library,
-     * clearing the visited fragments and fragment instances maps, and creating a new instance of the Web-IFC library.
-     *
-     * @remarks
-     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * ifcLoader.cleanUp();
-     * '''
-     */
-    cleanUp(): void;
-    private getAllGeometries;
-    private getMesh;
-    private getGeometry;
-    private autoSetWasm;
-}
-import * as WEBIFC from "web-ifc";
 import { Components, Disposable, Event, Component } from "../../core";
 import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
 /**
@@ -2078,202 +2216,23 @@ export declare class IfcPropertiesTiler extends Component implements Disposable
     private cleanUp;
 }
 import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
-import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
+import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
 /**
- * Configuration interface for the VertexPicker component.
+ * A class representing a 2D minimap of a 3D world.
  */
-export interface VertexPickerConfig {
+export declare class MiniMap implements Resizeable, Updateable, Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Resizeable.onResize} */
+    readonly onResize: Event<THREE.Vector2>;
     /**
-     * If true, only vertices will be picked, not the closest point on the face.
-     */
-    showOnlyVertex: boolean;
-    /**
-     * The maximum distance for snapping to a vertex.
-     */
-    snapDistance: number;
-    /**
-     * The HTML element to use for previewing the picked vertex.
-     */
-    previewElement: HTMLElement;
-}
-/**
- * A class that provides functionality for picking vertices in a 3D scene.
- */
-export declare class VertexPicker extends Component implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a vertex is found.
-     * The event passes a THREE.Vector3 representing the position of the found vertex.
-     */
-    readonly onVertexFound: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
-     */
-    readonly onVertexLost: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when the picker is enabled or disabled
-     */
-    readonly onEnabled: Event<boolean>;
-    /**
-     * A reference to the Components instance associated with this VertexPicker.
-     */
-    components: Components;
-    /**
-     * A reference to the working plane used for vertex picking.
-     * This plane is used to determine which vertices are considered valid for picking.
-     * If this value is null, all vertices are considered valid.
-     */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
-    /**
-     * Sets the enabled state of the VertexPicker.
-     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
-     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
-     *
-     * @param value - The new enabled state.
-     */
-    set enabled(value: boolean);
-    /**
-     * Gets the current enabled state of the VertexPicker.
-     *
-     * @returns The current enabled state.
-     */
-    get enabled(): boolean;
-    /**
-     * Sets the configuration for the VertexPicker component.
-     *
-     * @param value - A Partial object containing the configuration properties to update.
-     * The properties not provided in the value object will retain their current values.
-     *
-     * @example
-     * '''typescript
-     * vertexPicker.config = {
-     *   snapDistance: 0.5,
-     *   showOnlyVertex: true,
-     * };
-     * '''
-     */
-    set config(value: Partial<VertexPickerConfig>);
-    /**
-     * Gets the current configuration for the VertexPicker component.
-     *
-     * @returns A copy of the current VertexPickerConfig object.
-     *
-     * @example
-     * '''typescript
-     * const currentConfig = vertexPicker.config;
-     * console.log(currentConfig.snapDistance); // Output: 0.25
-     * '''
-     */
-    get config(): Partial<VertexPickerConfig>;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Performs the vertex picking operation based on the current state of the VertexPicker.
-     *
-     * @param world - The World instance to use for raycasting.
-     *
-     * @returns The current picked point, or null if no point is picked.
-     *
-     * @remarks
-     * This method checks if the VertexPicker is enabled. If not, it returns the current picked point.
-     * If enabled, it performs raycasting to find the closest intersecting object.
-     * It then determines the closest vertex or point on the face, based on the configuration settings.
-     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
-     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
-     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
-     */
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
-}
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
-}
-import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}
-/**
- * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
- *
- * @remarks
- * This map is used to provide a mapping between IFC entity type numbers and their names.
- * It is useful for identifying and processing different types of IFC elements in a project.
- *
- */
-export declare const IfcElements: {
-    [key: number]: string;
-};
-/**
- * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
- */
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
-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>>>;
-}
-/**
- * A Set of unique numbers representing different types of IFC geometries.
- */
-export declare const GeometryTypes: Set<number>;
-import * as THREE from "three";
-import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
-/**
- * A class representing a 2D minimap of a 3D world.
- */
-export declare class MiniMap implements Resizeable, Updateable, Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
      */
     frontOffset: number;
     /**
@@ -2345,11 +2304,77 @@ 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;
+}
+/**
+ * A Set of unique numbers representing different types of IFC geometries.
+ */
+export declare const GeometryTypes: Set<number>;
 import { InverseAttribute } from "./types";
 export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856 | 2857406711 | 2565941209 | 2495723537 | 3268803585, {
     forRelating: InverseAttribute;
     forRelated: InverseAttribute;
 }>;
+/**
+ * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
+ *
+ * @remarks
+ * This map is used to provide a mapping between IFC entity type numbers and their names.
+ * It is useful for identifying and processing different types of IFC elements in a project.
+ *
+ */
+export declare const IfcElements: {
+    [key: number]: string;
+};
+/**
+ * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
+ */
+export declare const IfcCategoryMap: {
+    [key: number]: string;
+};
+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>>>;
+}
+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;
+}
+import * as FRAGS from "@thatopen/fragments";
+import * as WEBIFC from "web-ifc";
+export declare class SpatialIdsFinder {
+    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+}
 import * as WEBIFC from "web-ifc";
 /** Configuration of the IFC-fragment conversion. */
 export declare class IfcFragmentSettings {
@@ -2393,152 +2418,6 @@ export declare class IfcFragmentSettings {
      */
     customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
 }
-import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
-/**
- * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
- *
- * @template T - The type of the scene. Default is BaseScene.
- * @template U - The type of the camera. Default is BaseCamera.
- * @template S - The type of the renderer. Default is BaseRenderer.
- */
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
-    /**
-     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
-     */
-    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
-     */
-    isDisposing: boolean;
-    /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
-     */
-    enabled: boolean;
-    /**
-     * A unique identifier for the world.
-     */
-    uuid: string;
-    /**
-     * An optional name for the world.
-     */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
-    /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
-     */
-    get scene(): T;
-    /**
-     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
-     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
-     * @param scene - The new scene to be set.
-     */
-    set scene(scene: T);
-    /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
-     */
-    get camera(): U;
-    /**
-     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
-     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
-     * @param camera - The new camera to be set.
-     */
-    set camera(camera: U);
-    /**
-     * Getter for the renderer.
-     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
-     */
-    get renderer(): S | null;
-    /**
-     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
-     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
-     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
-     * @param renderer - The new renderer to be set or null to remove the current renderer.
-     */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
-    /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
-}
-import * as THREE from "three";
-import { Event, World } from "../../Types";
-import { Components } from "../../Components";
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class DistanceRenderer {
-    /** {@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 onDistanceComputed: Event<number>;
-    /**
-     * Objects that won't be taken into account in the distance check.
-     */
-    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
-    /**
-     * Whether this renderer is active or not. If not, it won't render anything.
-     */
-    enabled: boolean;
-    /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
-     */
-    renderDebugFrame: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /**
-     * The scene where the distance is computed.
-     */
-    scene: THREE.Scene;
-    /**
-     * The camera used to compute the distance.
-     */
-    camera: THREE.OrthographicCamera;
-    /**
-     * The material used to compute the distance.
-     */
-    depthMaterial: THREE.ShaderMaterial;
-    /** The world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected readonly worker: Worker;
-    private _width;
-    private _height;
-    private readonly _postQuad;
-    private readonly tempRT;
-    private readonly resultRT;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World);
-    /** {@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.
-     */
-    compute: () => Promise<void>;
-    private handleWorkerMessage;
-}
 /**
  * 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.
  */
@@ -2567,99 +2446,6 @@ export declare class Event<T> {
     reset(): void;
     private handlers;
 }
-import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
-import { Components } from "../../Components";
-/**
- * Configuration interface for the {@link SimpleScene}. Defines properties for directional and ambient lights.
- */
-export interface SimpleSceneConfig {
-    directionalLight: {
-        color: THREE.Color;
-        intensity: number;
-        position: THREE.Vector3;
-    };
-    ambientLight: {
-        color: THREE.Color;
-        intensity: number;
-    };
-}
-/**
- * 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.
- */
-export declare class SimpleScene extends BaseScene implements Configurable<{}> {
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /**
-     * The underlying Three.js scene object.
-     * It is used to define the 3D space containing objects, lights, and cameras.
-     */
-    three: THREE.Scene;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<SimpleScene>;
-    /**
-     * Configuration interface for the {@link SimpleScene}.
-     * Defines properties for directional and ambient lights.
-     */
-    config: Required<SimpleSceneConfig>;
-    constructor(components: Components);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): void;
-}
-import * as THREE from "three";
-import { BaseRenderer, Event } from "../../Types";
-import { Components } from "../../Components";
-/**
- * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
- */
-export declare class SimpleRenderer extends BaseRenderer {
-    /**
-     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
-     * Default is 'true'.
-     */
-    enabled: boolean;
-    /**
-     * The HTML container of the THREE.js canvas where the scene is rendered.
-     */
-    container: HTMLElement;
-    /**
-     * The THREE.js WebGLRenderer instance.
-     */
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
-    /**
-     * Constructor for the SimpleRenderer class.
-     *
-     * @param components - The components instance.
-     * @param container - The HTML container where the THREE.js canvas will be rendered.
-     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
-     */
-    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;
-    /**
-     * Sets up and manages the event listeners for the renderer.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
-     *
-     * @throws Will throw an error if the renderer does not have an HTML container.
-     */
-    setupEvents(active: boolean): void;
-    private resizeEvent;
-    private setupRenderer;
-    private onContextLost;
-    private onContextBack;
-}
 /**
  * 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.
  */
@@ -2688,80 +2474,18 @@ export declare class AsyncEvent<T> {
     reset(): void;
     private handlers;
 }
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
-import { Components } from "../../Components";
+import { Base } from "./base";
 /**
- * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
+ * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
  */
-export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<SimpleCamera>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<SimpleCamera>;
+export declare abstract class Component extends Base {
     /**
-     * Event that is triggered when the aspect of the camera has been updated.
-     * This event is useful when you need to perform actions after the aspect of the camera has been changed.
+     * 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.
      */
-    readonly onAspectUpdated: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * A three.js PerspectiveCamera or OrthographicCamera instance.
-     * This camera is used for rendering the scene.
-     */
-    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    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;
-    /**
-     * Getter for the enabled state of the camera controls.
-     * If the current world is null, it returns false.
-     * Otherwise, it returns the enabled state of the camera controls.
-     *
-     * @returns {boolean} The enabled state of the camera controls.
-     */
-    get enabled(): boolean;
-    /**
-     * Setter for the enabled state of the camera controls.
-     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
-     *
-     * @param {boolean} enabled - The new enabled state of the camera controls.
-     */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
-    /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
-     */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
-}
-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;
-}
-import * as FRAGS from "@thatopen/fragments";
-import * as WEBIFC from "web-ifc";
-export declare class SpatialIdsFinder {
-    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+    abstract enabled: boolean;
 }
 import * as THREE from "three";
 import CameraControls from "camera-controls";
@@ -2891,19 +2615,6 @@ export declare abstract class Base {
     isConfigurable: () => this is Configurable<any>;
 }
 import { Base } from "./base";
-/**
- * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), 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 { Base } from "./base";
 import { World } from "./world";
 import { Event } from "./event";
 import { Components } from "../../Components";
@@ -3017,140 +2728,483 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
      * The 'three.clippingPlanes' property is then updated to reflect the current state of the 'clippingPlanes' array,
      * excluding any planes marked as local.
      */
-    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
+    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";
+/**
+ * Abstract class representing a base scene in the application. All scenes should use this class as a base.
+ */
+export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Abstract property representing the three.js object associated with this scene.
+     * It should be implemented by subclasses.
+     */
+    abstract three: THREE.Object3D;
+    /** The set of directional lights managed by this scene component. */
+    directionalLights: Map<string, THREE.DirectionalLight>;
+    /** The set of ambient lights managed by this scene component. */
+    ambientLights: Map<string, THREE.AmbientLight>;
+    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";
+/**
+ * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
+ */
+export interface World extends Disposable, Updateable {
+    /**
+     * A set of meshes present in the world. This is taken into account for operations like raycasting.
+     */
+    meshes: Set<THREE.Mesh>;
+    /**
+     * The base scene of the world.
+     */
+    scene: BaseScene;
+    /**
+     * The base camera of the world.
+     */
+    camera: BaseCamera;
+    /**
+     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
+     */
+    renderer: BaseRenderer | null;
+    /**
+     * A unique identifier for the world.
+     */
+    uuid: string;
+    /**
+     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     */
+    isDisposing: boolean;
+}
+import { Event } from "./event";
+/**
+ * A class that extends the built-in Map class and provides additional events for item set, update, delete, and clear operations.
+ *
+ * @template K - The type of keys in the map.
+ * @template V - The type of values in the map.
+ */
+export declare class DataMap<K, V> extends Map<K, V> {
+    /**
+     * An event triggered when a new item is set in the map.
+     */
+    readonly onItemSet: Event<{
+        key: K;
+        value: V;
+    }>;
+    /**
+     * An event triggered when an existing item in the map is updated.
+     */
+    readonly onItemUpdated: Event<{
+        key: K;
+        value: V;
+    }>;
+    /**
+     * An event triggered when an item is deleted from the map.
+     */
+    readonly onItemDeleted: Event<unknown>;
+    /**
+     * An event triggered when the map is cleared.
+     */
+    readonly onCleared: Event<unknown>;
+    /**
+     * Constructs a new DataMap instance.
+     *
+     * @param iterable - An iterable object containing key-value pairs to populate the map.
+     */
+    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
+    /**
+     * Clears the map and triggers the onCleared event.
+     */
+    clear(): void;
+    /**
+     * Sets the value for the specified key in the map and triggers the appropriate event (onItemSet or onItemUpdated).
+     *
+     * @param key - The key of the item to set.
+     * @param value - The value of the item to set.
+     * @returns The DataMap instance.
+     */
+    set(key: K, value: V): this;
+    /**
+     * Deletes the specified key from the map and triggers the onItemDeleted event if the key was found.
+     *
+     * @param key - The key of the item to delete.
+     * @returns True if the key was found and deleted; otherwise, false.
+     */
+    delete(key: K): boolean;
+    /**
+     * Clears the map and resets the events.
+     */
+    dispose(): void;
+}
+import { Event } from "./event";
+/**
+ * A class that extends the built-in Set class and provides additional functionality.
+ * It triggers events when items are added, deleted, or the set is cleared.
+ *
+ * @template T - The type of elements in the set.
+ */
+export declare class DataSet<T> extends Set<T> {
+    /**
+     * An event that is triggered when a new item is added to the set.
+     */
+    readonly onItemAdded: Event<T>;
+    /**
+     * An event that is triggered when an item is deleted from the set.
+     */
+    readonly onItemDeleted: Event<unknown>;
+    /**
+     * An event that is triggered when the set is cleared.
+     */
+    readonly onCleared: Event<unknown>;
+    /**
+     * Constructs a new instance of the DataSet class.
+     *
+     * @param iterable - An optional iterable object to initialize the set with.
+     */
+    constructor(iterable?: Iterable<T> | null);
+    /**
+     * Clears the set and triggers the onCleared event.
+     */
+    clear(): void;
+    /**
+     * Adds a value to the set and triggers the onItemAdded event.
+     *
+     * @param value - The value to add to the set.
+     * @returns - The set instance.
+     */
+    add(value: T): this;
+    /**
+     * Deletes a value from the set and triggers the onItemDeleted event.
+     *
+     * @param value - The value to delete from the set.
+     * @returns - True if the value was successfully deleted, false otherwise.
+     */
+    delete(value: T): boolean;
+    /**
+     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
+     */
+    dispose(): void;
+}
+import * as THREE from "three";
+import { Disposable, Event } from "../../Types";
+/**
+ * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
+ */
+export declare class Mouse implements Disposable {
+    dom: HTMLCanvasElement;
+    private _event?;
+    private _position;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    constructor(dom: HTMLCanvasElement);
+    /**
+     * The real position of the mouse of the Three.js canvas.
+     */
+    get position(): THREE.Vector2;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private getPositionY;
+    private getPositionX;
+    private updateMouseInfo;
+    private setupEvents;
+}
+import * as THREE from "three";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+import { Mouse } from "./mouse";
+/**
+ * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
+ */
+export declare class SimpleRaycaster implements Disposable {
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /** The components instance to which this Raycaster belongs. */
+    components: Components;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** The position of the mouse in the screen. */
+    readonly mouse: Mouse;
+    /**
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
+     */
+    readonly three: THREE.Raycaster;
+    /**
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
+     */
+    world: World;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Throws a ray from the camera to the mouse or touch event point and returns
+     * the first item found. This also takes into account the clipping planes
+     * used by the renderer.
+     *
+     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
+     * to query. If not provided, it will query all the meshes stored in
+     * {@link Components.meshes}.
+     */
+    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    /**
+     * Casts a ray from a given origin in a given direction and returns the first item found.
+     * This method also takes into account the clipping planes used by the renderer.
+     *
+     * @param origin - The origin of the ray.
+     * @param direction - The direction of the ray.
+     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
+     * @returns The first intersection found or 'null' if no intersection was found.
+     */
+    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
+    private intersect;
+    private filterClippingPlanes;
+}
+import * as THREE from "three";
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+/**
+ * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
+ *
+ * @template T - The type of the scene. Default is BaseScene.
+ * @template U - The type of the camera. Default is BaseCamera.
+ * @template S - The type of the renderer. Default is BaseRenderer.
+ */
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
+    /**
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
+     */
+    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
+     */
+    isDisposing: boolean;
+    /**
+     * Indicates whether the world is currently enabled.
+     * When disabled, the world will not be updated.
+     */
+    enabled: boolean;
+    /**
+     * A unique identifier for the world.
+     */
+    uuid: string;
+    /**
+     * An optional name for the world.
+     */
+    name?: string;
+    private _scene?;
+    private _camera?;
+    private _renderer;
+    /**
+     * Getter for the scene. If no scene is initialized, it throws an error.
+     * @returns The current scene.
+     */
+    get scene(): T;
+    /**
+     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
+     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
+     * @param scene - The new scene to be set.
+     */
+    set scene(scene: T);
+    /**
+     * Getter for the camera. If no camera is initialized, it throws an error.
+     * @returns The current camera.
+     */
+    get camera(): U;
+    /**
+     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
+     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
+     * @param camera - The new camera to be set.
+     */
+    set camera(camera: U);
+    /**
+     * Getter for the renderer.
+     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
+     */
+    get renderer(): S | null;
+    /**
+     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
+     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
+     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
+     * @param renderer - The new renderer to be set or null to remove the current renderer.
+     */
+    set renderer(renderer: S | null);
+    /** {@link Updateable.update} */
+    update(delta?: number): void;
+    /** {@link Disposable.dispose} */
+    dispose(disposeResources?: boolean): void;
 }
 import * as THREE from "three";
-import { Disposable } from "./interfaces";
-import { Event } from "./event";
+import { BaseScene, Configurable, Event } from "../../Types";
 import { Components } from "../../Components";
-import { BaseWorldItem } from "./base-world-item";
 /**
- * Abstract class representing a base scene in the application. All scenes should use this class as a base.
+ * Configuration interface for the {@link SimpleScene}. Defines properties for directional and ambient lights.
  */
-export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Abstract property representing the three.js object associated with this scene.
-     * It should be implemented by subclasses.
-     */
-    abstract three: THREE.Object3D;
-    /** The set of directional lights managed by this scene component. */
-    directionalLights: Map<string, THREE.DirectionalLight>;
-    /** The set of ambient lights managed by this scene component. */
-    ambientLights: Map<string, THREE.AmbientLight>;
-    protected constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+export interface SimpleSceneConfig {
+    directionalLight: {
+        color: THREE.Color;
+        intensity: number;
+        position: THREE.Vector3;
+    };
+    ambientLight: {
+        color: THREE.Color;
+        intensity: number;
+    };
 }
-import { Event } from "./event";
 /**
- * A class that extends the built-in Map class and provides additional events for item set, update, delete, and clear operations.
- *
- * @template K - The type of keys in the map.
- * @template V - The type of values in the map.
+ * 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.
  */
-export declare class DataMap<K, V> extends Map<K, V> {
-    /**
-     * An event triggered when a new item is set in the map.
-     */
-    readonly onItemSet: Event<{
-        key: K;
-        value: V;
-    }>;
+export declare class SimpleScene extends BaseScene implements Configurable<{}> {
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
     /**
-     * An event triggered when an existing item in the map is updated.
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
      */
-    readonly onItemUpdated: Event<{
-        key: K;
-        value: V;
-    }>;
+    three: THREE.Scene;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<SimpleScene>;
     /**
-     * An event triggered when an item is deleted from the map.
+     * Configuration interface for the {@link SimpleScene}.
+     * Defines properties for directional and ambient lights.
      */
-    readonly onItemDeleted: Event<unknown>;
+    config: Required<SimpleSceneConfig>;
+    constructor(components: Components);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleSceneConfig>): void;
+}
+import * as THREE from "three";
+import { BaseRenderer, Event } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
+ */
+export declare class SimpleRenderer extends BaseRenderer {
     /**
-     * An event triggered when the map is cleared.
+     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
+     * Default is 'true'.
      */
-    readonly onCleared: Event<unknown>;
+    enabled: boolean;
     /**
-     * Constructs a new DataMap instance.
-     *
-     * @param iterable - An iterable object containing key-value pairs to populate the map.
+     * The HTML container of the THREE.js canvas where the scene is rendered.
      */
-    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
+    container: HTMLElement;
     /**
-     * Clears the map and triggers the onCleared event.
+     * The THREE.js WebGLRenderer instance.
      */
-    clear(): void;
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<unknown>;
+    private _resizing;
     /**
-     * Sets the value for the specified key in the map and triggers the appropriate event (onItemSet or onItemUpdated).
+     * Constructor for the SimpleRenderer class.
      *
-     * @param key - The key of the item to set.
-     * @param value - The value of the item to set.
-     * @returns The DataMap instance.
+     * @param components - The components instance.
+     * @param container - The HTML container where the THREE.js canvas will be rendered.
+     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
      */
-    set(key: K, value: V): this;
+    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;
     /**
-     * Deletes the specified key from the map and triggers the onItemDeleted event if the key was found.
+     * Sets up and manages the event listeners for the renderer.
      *
-     * @param key - The key of the item to delete.
-     * @returns True if the key was found and deleted; otherwise, false.
-     */
-    delete(key: K): boolean;
-    /**
-     * Clears the map and resets the events.
+     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
+     *
+     * @throws Will throw an error if the renderer does not have an HTML container.
      */
-    dispose(): void;
+    setupEvents(active: boolean): void;
+    private resizeEvent;
+    private setupRenderer;
+    private onContextLost;
+    private onContextBack;
 }
-import { Event } from "./event";
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
+import { Components } from "../../Components";
 /**
- * A class that extends the built-in Set class and provides additional functionality.
- * It triggers events when items are added, deleted, or the set is cleared.
- *
- * @template T - The type of elements in the set.
+ * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
  */
-export declare class DataSet<T> extends Set<T> {
-    /**
-     * An event that is triggered when a new item is added to the set.
-     */
-    readonly onItemAdded: Event<T>;
-    /**
-     * An event that is triggered when an item is deleted from the set.
-     */
-    readonly onItemDeleted: Event<unknown>;
+export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<SimpleCamera>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<SimpleCamera>;
     /**
-     * An event that is triggered when the set is cleared.
+     * Event that is triggered when the aspect of the camera has been updated.
+     * This event is useful when you need to perform actions after the aspect of the camera has been changed.
      */
-    readonly onCleared: Event<unknown>;
+    readonly onAspectUpdated: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Constructs a new instance of the DataSet class.
-     *
-     * @param iterable - An optional iterable object to initialize the set with.
+     * A three.js PerspectiveCamera or OrthographicCamera instance.
+     * This camera is used for rendering the scene.
      */
-    constructor(iterable?: Iterable<T> | null);
+    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    private _allControls;
     /**
-     * Clears the set and triggers the onCleared 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.
      */
-    clear(): void;
+    get controls(): CameraControls;
     /**
-     * Adds a value to the set and triggers the onItemAdded event.
+     * Getter for the enabled state of the camera controls.
+     * If the current world is null, it returns false.
+     * Otherwise, it returns the enabled state of the camera controls.
      *
-     * @param value - The value to add to the set.
-     * @returns - The set instance.
+     * @returns {boolean} The enabled state of the camera controls.
      */
-    add(value: T): this;
+    get enabled(): boolean;
     /**
-     * Deletes a value from the set and triggers the onItemDeleted event.
+     * Setter for the enabled state of the camera controls.
+     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
      *
-     * @param value - The value to delete from the set.
-     * @returns - True if the value was successfully deleted, false otherwise.
+     * @param {boolean} enabled - The new enabled state of the camera controls.
      */
-    delete(value: T): boolean;
+    set enabled(enabled: boolean);
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(_delta: number): void;
     /**
-     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
      */
-    dispose(): void;
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
 }
 import * as THREE from "three";
 import { Components } from "../../Components";
@@ -3235,48 +3289,13 @@ export declare class CullerRenderer {
     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 { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
-/**
- * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
- */
-export interface World extends Disposable, Updateable {
-    /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
-     */
-    meshes: Set<THREE.Mesh>;
-    /**
-     * The base scene of the world.
-     */
-    scene: BaseScene;
-    /**
-     * The base camera of the world.
-     */
-    camera: BaseCamera;
-    /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
-     */
-    renderer: BaseRenderer | null;
-    /**
-     * A unique identifier for the world.
-     */
-    uuid: string;
-    /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
-     */
-    isDisposing: boolean;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
+    private applySettings;
 }
 import * as THREE from "three";
 import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
@@ -3342,80 +3361,255 @@ export declare class MeshCullerRenderer extends CullerRenderer implements Dispos
     private handleWorkerMessage;
     private getAvailableMaterial;
 }
+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 { Hideable, Event, World, Disposable } from "../../Types";
 import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
 /**
- * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
+ * Configuration interface for the {@link SimpleGrid} class.
  */
-export declare class SimpleRaycaster implements Disposable {
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** The components instance to which this Raycaster belongs. */
-    components: Components;
+export interface GridConfig {
+    /**
+     * The color of the grid lines.
+     */
+    color: THREE.Color;
+    /**
+     * The size of the primary grid lines.
+     */
+    size1: number;
+    /**
+     * The size of the secondary grid lines.
+     */
+    size2: number;
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
+    distance: 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).
+ */
+export declare class SimpleGrid implements Hideable, Disposable {
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    /** The position of the mouse in the screen. */
-    readonly mouse: Mouse;
+    /** The world instance to which this Raycaster belongs. */
+    world: World;
+    /** The components instance to which this grid belongs. */
+    components: Components;
+    /** {@link Hideable.visible} */
+    get visible(): boolean;
+    /** {@link Hideable.visible} */
+    set visible(visible: boolean);
+    /** The material of the grid. */
+    get material(): THREE.ShaderMaterial;
     /**
-     * A reference to the Three.js Raycaster instance.
-     * This is used for raycasting operations.
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    readonly three: THREE.Raycaster;
+    get fade(): boolean;
     /**
-     * A reference to the world instance to which this Raycaster belongs.
-     * This is used to access the camera and meshes.
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    world: World;
-    constructor(components: Components, world: World);
+    set fade(active: boolean);
+    /** The Three.js mesh that contains the infinite grid. */
+    readonly three: THREE.Mesh;
+    private _fade;
+    constructor(components: Components, world: World, config: GridConfig);
     /** {@link Disposable.dispose} */
     dispose(): void;
+    private setupEvents;
+    private updateZoom;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * 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: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
+ */
+export declare class OrbitMode implements NavigationMode {
+    camera: OrthoPerspectiveCamera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * 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: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+}
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
     /**
-     * Throws a ray from the camera to the mouse or touch event point and returns
-     * the first item found. This also takes into account the clipping planes
-     * used by the renderer.
-     *
-     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
-     * to query. If not provided, it will query all the meshes stored in
-     * {@link Components.meshes}.
+     * Event that fires when the {@link CameraProjection} changes.
      */
-    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
     /**
-     * Casts a ray from a given origin in a given direction and returns the first item found.
-     * This method also takes into account the clipping planes used by the renderer.
+     * Current projection mode of the camera.
+     * Default is "Perspective".
+     */
+    current: CameraProjection;
+    /**
+     * The camera controlled by this ProjectionManager.
+     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     */
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    private _component;
+    private _previousDistance;
+    constructor(camera: OrthoPerspectiveCamera);
+    /**
+     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
      *
-     * @param origin - The origin of the ray.
-     * @param direction - The direction of the ray.
-     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
-     * @returns The first intersection found or 'null' if no intersection was found.
+     * @param projection - the new projection to set. If it is the current projection,
+     * it will have no effect.
      */
-    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
-    private intersect;
-    private filterClippingPlanes;
+    set(projection: CameraProjection): Promise<void>;
+    /**
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
+     */
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getPerspectiveDims;
+    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 * as THREE from "three";
-import { Disposable, Event } from "../../Types";
+import { Event, World } from "../../Types";
+import { Components } from "../../Components";
 /**
- * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
+ * A base renderer to determine visibility on screen.
  */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
+export declare class DistanceRenderer {
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
+    readonly onDisposed: Event<string>;
     /**
-     * The real position of the mouse of the Three.js canvas.
+     * 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.
      */
-    get position(): THREE.Vector2;
+    readonly onDistanceComputed: Event<number>;
+    /**
+     * Objects that won't be taken into account in the distance check.
+     */
+    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
+    /**
+     * Whether this renderer is active or not. If not, it won't render anything.
+     */
+    enabled: boolean;
+    /**
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
+     */
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /**
+     * The scene where the distance is computed.
+     */
+    scene: THREE.Scene;
+    /**
+     * The camera used to compute the distance.
+     */
+    camera: THREE.OrthographicCamera;
+    /**
+     * The material used to compute the distance.
+     */
+    depthMaterial: THREE.ShaderMaterial;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected readonly worker: Worker;
+    private _width;
+    private _height;
+    private readonly _postQuad;
+    private readonly tempRT;
+    private readonly resultRT;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private setupEvents;
+    /**
+     * 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.
+     */
+    compute: () => Promise<void>;
+    private handleWorkerMessage;
 }
 import * as THREE from "three";
 import { Hideable, Disposable, Event, World } from "../../Types";
@@ -3516,82 +3710,16 @@ export declare class SimplePlane implements Disposable, Hideable {
     private newHelper;
     private static newPlaneMesh;
 }
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * 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: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private setupFirstPersonCamera;
-}
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
- */
-export declare class OrbitMode implements NavigationMode {
-    camera: OrthoPerspectiveCamera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Orbit";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private activateOrbitControls;
-}
-import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
+import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
  */
-export declare class ProjectionManager {
-    /**
-     * Event that fires when the {@link CameraProjection} changes.
-     */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
-    /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
-     */
-    current: CameraProjection;
-    /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
-     */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    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>;
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
     /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
      */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
+    propertiesSize: number;
 }
 import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
@@ -3610,65 +3738,6 @@ export declare class IfcStreamingSettings extends IfcFragmentSettings {
     minAssetsSize: number;
 }
 import * as THREE from "three";
-import { Hideable, Event, World, Disposable } from "../../Types";
-import { Components } from "../../Components";
-/**
- * Configuration interface for the {@link SimpleGrid} class.
- */
-export interface GridConfig {
-    /**
-     * The color of the grid lines.
-     */
-    color: THREE.Color;
-    /**
-     * The size of the primary grid lines.
-     */
-    size1: number;
-    /**
-     * The size of the secondary grid lines.
-     */
-    size2: number;
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    distance: 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).
- */
-export declare class SimpleGrid implements Hideable, Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The world instance to which this Raycaster belongs. */
-    world: World;
-    /** The components instance to which this grid belongs. */
-    components: Components;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    get fade(): boolean;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    set fade(active: boolean);
-    /** The Three.js mesh that contains the infinite grid. */
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World, config: GridConfig);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
-}
-import * as THREE from "three";
 import * as WEBIFC from "web-ifc";
 import * as FRAGS from "@thatopen/fragments";
 export declare class CivilReader {
@@ -3683,78 +3752,6 @@ export declare class CivilReader {
     } | undefined;
     private getCurves;
 }
-/**
- * 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 { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * 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: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-}
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-}
-import { IfcFragmentSettings } from "../../IfcLoader/src";
-/**
- * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
- */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
-    /**
-     * Amount of properties to be streamed.
-     * Defaults to 100 properties.
-     */
-    propertiesSize: number;
-}
-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;
-}
 /**
  * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
  */
@@ -3785,6 +3782,26 @@ export interface StreamedAsset {
     }[];
 }
 import * as WEBIFC from "web-ifc";
+export declare class IfcMetadataReader {
+    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+}
+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 { BufferGeometry } from "three";
+import * as THREE from "three";
+export declare class TransformHelper {
+    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
+}
+import * as WEBIFC from "web-ifc";
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
     [modelID: string]: RelationsMap;
@@ -3839,10 +3856,5 @@ export type IfcRelations = [
     typeof WEBIFC.IFCRELNESTS
 ];
 export type IfcRelation = IfcRelations[number];
-import { BufferGeometry } from "three";
-import * as THREE from "three";
-export declare class TransformHelper {
-    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
-}
 
 }