@thatopen/components 2.1.10 → 2.1.11

package/dist/namespace.d.ts

@@ -1,53 +1,4 @@
 declare namespace OBC {
-import { Component, Disposable, World, Event } from "../Types";
-import { GridConfig, SimpleGrid } from "./src";
-import { Components } from "../Components";
-/**
- * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
- */
-export declare class Grids 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: "d1e814d5-b81c-4452-87a2-f039375e0489";
-    /**
-     * A map of world UUIDs to their corresponding grid instances.
-     */
-    list: Map<string, SimpleGrid>;
-    /**
-     * The default configuration for grid creation.
-     */
-    config: Required<GridConfig>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Creates a new grid for the given world.
-     * Throws an error if a grid already exists for the world.
-     *
-     * @param world - The world to create the grid for.
-     * @returns The newly created grid.
-     *
-     * @throws Will throw an error if a grid already exists for the given world.
-     */
-    create(world: World): SimpleGrid;
-    /**
-     * Deletes the grid associated with the given world.
-     * If a grid does not exist for the given world, this method does nothing.
-     *
-     * @param world - The world for which to delete the grid.
-     *
-     * @remarks
-     * This method will dispose of the grid and remove it from the internal list.
-     * If the world is disposed before calling this method, the grid will be automatically deleted.
-     */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}
 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.
@@ -56,7 +7,7 @@ export declare class Components implements Disposable {
     /**
      * The version of the @thatopen/components library.
      */
-    static readonly release = "2.1.10";
+    static readonly release = "2.1.11";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
     /**
@@ -125,137 +76,6 @@ export declare class Components implements Disposable {
     private static setupBVH;
 }
 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
-     * clipping plane is created in its roof, which might have a slight
-     * slope for draining purposes.
-     */
-    orthogonalY: boolean;
-    /**
-     * The tolerance that determines whether an almost-horizontal clipping plane
-     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
-     * has to be 'true' for this to apply.
-     */
-    toleranceOrthogonalY: number;
-    /**
-     * The type of clipping plane to be created.
-     * Default is {@link SimplePlane}.
-     */
-    Type: new (...args: any) => SimplePlane;
-    /**
-     * A list of all the clipping planes created by this component.
-     */
-    list: SimplePlane[];
-    /** The material used in all the clipping planes. */
-    private _material;
-    private _size;
-    private _enabled;
-    private _visible;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The material of the clipping plane representation. */
-    get material(): THREE.MeshBasicMaterial;
-    /** The material of the clipping plane representation. */
-    set material(material: THREE.MeshBasicMaterial);
-    /** The size of the geometric representation of the clippings planes. */
-    get size(): number;
-    /** The size of the geometric representation of the clippings planes. */
-    set size(size: number);
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Createable.create} */
-    create(world: World): SimplePlane | null;
-    /**
-     * Creates a plane in a certain place and with a certain orientation,
-     * without the need of the mouse.
-     *
-     * @param world - the world where this plane should be created.
-     * @param normal - the orientation of the clipping plane.
-     * @param point - the position of the clipping plane.
-     * navigation.
-     */
-    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): SimplePlane;
-    /**
-     * {@link Createable.delete}
-     *
-     * @param world - the world where the plane to delete is.
-     * @param plane - the plane to delete. If undefined, the first plane
-     * found under the cursor will be deleted.
-     */
-    delete(world: World, plane?: SimplePlane): void;
-    /**
-     * Deletes all the existing clipping planes.
-     *
-     * @param types - the types of planes to be deleted. If not provided, all planes will be deleted.
-     */
-    deleteAll(types?: Set<string>): void;
-    private deletePlane;
-    private pickPlane;
-    private getAllPlaneMeshes;
-    private createPlaneFromIntersection;
-    private getWorldNormal;
-    private normalizePlaneDirectionY;
-    private newPlane;
-    private updateMaterialsAndPlanes;
-    private _onStartDragging;
-    private _onEndDragging;
-}
-import * as THREE from "three";
 import { Components } from "../Components";
 import { Component } from "../Types";
 /**
@@ -300,6 +120,48 @@ export declare class Disposer extends Component {
     private disposeChildren;
     private static disposeMaterial;
 }
+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 { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
 import { Components } from "../Components";
 import { SimpleWorld } from "./src";
@@ -367,94 +229,101 @@ export declare class Worlds extends Component implements Updateable, Disposable
     /** {@link Updateable.update} */
     update(delta?: number): void | Promise<void>;
 }
-import { MiniMap } from "./src";
-import { Component, Updateable, World, Event, Disposable } from "../Types";
+import { Component, Disposable, World, Event } from "../Types";
+import { GridConfig, SimpleGrid } from "./src";
 import { Components } from "../Components";
 /**
- * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
+ * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
  */
-export declare class MiniMaps extends Component implements Updateable, Disposable {
+export declare class Grids 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: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
+    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
+    /**
+     * A map of world UUIDs to their corresponding grid instances.
+     */
+    list: Map<string, SimpleGrid>;
+    /**
+     * The default configuration for grid creation.
+     */
+    config: Required<GridConfig>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
     /** {@link Component.enabled} */
     enabled: boolean;
-    /**
-     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
-     */
-    list: Map<string, MiniMap>;
     constructor(components: Components);
     /**
-     * Creates a new {@link MiniMap} instance associated with the given world.
-     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
+     * Creates a new grid for the given world.
+     * Throws an error if a grid already exists for the world.
      *
-     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
-     * @returns The newly created {@link MiniMap} instance.
-     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
-     */
-    create(world: World): MiniMap;
+     * @param world - The world to create the grid for.
+     * @returns The newly created grid.
+     *
+     * @throws Will throw an error if a grid already exists for the given world.
+     */
+    create(world: World): SimpleGrid;
     /**
-     * Deletes a {@link MiniMap} instance associated with the given world ID.
-     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
+     * Deletes the grid associated with the given world.
+     * If a grid does not exist for the given world, this method does nothing.
      *
-     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
-     * @returns {void}
+     * @param world - The world for which to delete the grid.
+     *
+     * @remarks
+     * This method will dispose of the grid and remove it from the internal list.
+     * If the world is disposed before calling this method, the grid will be automatically deleted.
      */
-    delete(id: string): void;
+    delete(world: World): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
+import { MiniMap } from "./src";
+import { Component, Updateable, World, Event, Disposable } from "../Types";
 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).
+ * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
  */
-export declare class Raycasters extends Component implements Disposable {
+export declare class MiniMaps extends Component implements Updateable, 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";
+    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /** {@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.
+     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
      */
-    list: Map<string, SimpleRaycaster>;
-    /** {@link Disposable.onDisposed} */
-    onDisposed: Event<unknown>;
+    list: Map<string, MiniMap>;
     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.
+     * Creates a new {@link MiniMap} instance associated with the given world.
+     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
      *
-     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
-     * @returns The SimpleRaycaster instance for the given world.
+     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
+     * @returns The newly created {@link MiniMap} instance.
+     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
      */
-    get(world: World): SimpleRaycaster;
+    create(world: World): MiniMap;
     /**
-     * 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.
+     * Deletes a {@link MiniMap} instance associated with the given world ID.
+     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
      *
-     * @param world - The world for which to delete the SimpleRaycaster instance.
+     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
      * @returns {void}
      */
-    delete(world: World): void;
+    delete(id: string): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /** {@link Updateable.update} */
+    update(): void;
 }
 import { Components } from "../Components";
 import { MeshCullerRenderer, CullerRendererSettings } from "./src";
@@ -505,6 +374,137 @@ export declare class Cullers extends Component implements Disposable {
     dispose(): void;
 }
 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
+     * clipping plane is created in its roof, which might have a slight
+     * slope for draining purposes.
+     */
+    orthogonalY: boolean;
+    /**
+     * The tolerance that determines whether an almost-horizontal clipping plane
+     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
+     * has to be 'true' for this to apply.
+     */
+    toleranceOrthogonalY: number;
+    /**
+     * The type of clipping plane to be created.
+     * Default is {@link SimplePlane}.
+     */
+    Type: new (...args: any) => SimplePlane;
+    /**
+     * A list of all the clipping planes created by this component.
+     */
+    list: SimplePlane[];
+    /** The material used in all the clipping planes. */
+    private _material;
+    private _size;
+    private _enabled;
+    private _visible;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The material of the clipping plane representation. */
+    get material(): THREE.MeshBasicMaterial;
+    /** The material of the clipping plane representation. */
+    set material(material: THREE.MeshBasicMaterial);
+    /** The size of the geometric representation of the clippings planes. */
+    get size(): number;
+    /** The size of the geometric representation of the clippings planes. */
+    set size(size: number);
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Createable.create} */
+    create(world: World): SimplePlane | null;
+    /**
+     * Creates a plane in a certain place and with a certain orientation,
+     * without the need of the mouse.
+     *
+     * @param world - the world where this plane should be created.
+     * @param normal - the orientation of the clipping plane.
+     * @param point - the position of the clipping plane.
+     * navigation.
+     */
+    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): SimplePlane;
+    /**
+     * {@link Createable.delete}
+     *
+     * @param world - the world where the plane to delete is.
+     * @param plane - the plane to delete. If undefined, the first plane
+     * found under the cursor will be deleted.
+     */
+    delete(world: World, plane?: SimplePlane): void;
+    /**
+     * Deletes all the existing clipping planes.
+     *
+     * @param types - the types of planes to be deleted. If not provided, all planes will be deleted.
+     */
+    deleteAll(types?: Set<string>): void;
+    private deletePlane;
+    private pickPlane;
+    private getAllPlaneMeshes;
+    private createPlaneFromIntersection;
+    private getWorldNormal;
+    private normalizePlaneDirectionY;
+    private newPlane;
+    private updateMaterialsAndPlanes;
+    private _onStartDragging;
+    private _onEndDragging;
+}
+import * as THREE from "three";
 import { Components } from "../Components";
 import { SimpleCamera } from "..";
 import { NavigationMode, NavModeID, ProjectionManager } from "./src";
@@ -568,418 +568,454 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
     private newOrthoCamera;
     private setOrthoPerspCameraAspect;
 }
-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 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;
-import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
+import * as WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
 /**
- * Configuration interface for the VertexPicker component.
+ * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
  */
-export interface VertexPickerConfig {
-    /**
-     * If true, only vertices will be picked, not the closest point on the face.
-     */
-    showOnlyVertex: boolean;
+export declare class IfcJsonExporter extends Component {
     /**
-     * The maximum distance for snapping to a vertex.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    snapDistance: number;
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
     /**
-     * The HTML element to use for previewing the picked vertex.
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
      */
-    previewElement: HTMLElement;
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+}
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
 }
+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";
 /**
- * A class that provides functionality for picking vertices in a 3D scene.
+ * Types for boolean properties in IFC schema.
  */
-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.
+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.
      */
-    readonly onVertexFound: Event<THREE.Vector3>;
+    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
+     * Event triggered when a file is requested for export.
      */
-    readonly onVertexLost: Event<THREE.Vector3>;
+    readonly onRequestFile: Event<unknown>;
     /**
-     * An event that is triggered when the picker is enabled or disabled
+     * ArrayBuffer containing the IFC data to be exported.
      */
-    readonly onEnabled: Event<boolean>;
+    ifcToExport: ArrayBuffer | null;
     /**
-     * A reference to the Components instance associated with this VertexPicker.
+     * Event triggered when an element is added to a Pset.
      */
-    components: Components;
+    readonly onElementToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        elementID: number;
+    }>;
     /**
-     * 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.
+     * Event triggered when a property is added to a Pset.
      */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
+    readonly onPropToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        propID: number;
+    }>;
     /**
-     * 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.
+     * Event triggered when a Pset is removed.
      */
-    set enabled(value: boolean);
+    readonly onPsetRemoved: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+    }>;
     /**
-     * Gets the current enabled state of the VertexPicker.
-     *
-     * @returns The current enabled state.
+     * Event triggered when data in the model changes.
      */
-    get enabled(): boolean;
+    readonly onDataChanged: Event<{
+        model: FragmentsGroup;
+        expressID: number;
+    }>;
     /**
-     * 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,
-     * };
-     * '''
+     * Configuration for the WebAssembly module.
      */
-    set config(value: Partial<VertexPickerConfig>);
+    wasm: {
+        path: string;
+        absolute: boolean;
+    };
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * 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
-     * '''
+     * Map of attribute listeners.
      */
-    get config(): Partial<VertexPickerConfig>;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    attributeListeners: AttributeListener;
+    /**
+     * The currently selected model.
+     */
+    selectedModel?: FragmentsGroup;
+    /**
+     * Map of changed entities in the model.
+     */
+    changeMap: ChangeMap;
+    constructor(components: Components);
     /** {@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.
+     * Static method to retrieve the IFC schema from a given model.
      *
-     * @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'.
+     * @param model - The FragmentsGroup model from which to retrieve the IFC schema.
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @returns The IFC schema associated with the given model.
      */
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
-}
-import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Represents an edge measurement result.
- */
-export interface MeasureEdge {
+    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
     /**
-     * The distance between the two points of the edge.
+     * Method to set properties data in the model.
+     *
+     * @param model - The FragmentsGroup model in which to set the properties.
+     * @param dataToSave - An array of objects representing the properties to be saved.
+     * Each object must have an 'expressID' property, which is the express ID of the entity in the model.
+     * The rest of the properties will be set as the properties of the entity.
+     *
+     * @returns A promise that resolves when all the properties have been set.
+     *
+     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'dataToSave' array.
      */
-    distance: number;
+    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
     /**
-     * The two points that define the edge.
+     * Creates a new Property Set (Pset) in the given model.
+     *
+     * @param model - The FragmentsGroup model in which to create the Pset.
+     * @param name - The name of the Pset.
+     * @param description - (Optional) The description of the Pset.
+     *
+     * @returns A promise that resolves with an object containing the newly created Pset and its relation.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    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 {
+    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
+        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
+        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
+    }>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Removes a Property Set (Pset) from the given model.
+     *
+     * @param model - The FragmentsGroup model from which to remove the Pset.
+     * @param psetID - The express IDs of the Psets to be removed.
+     *
+     * @returns A promise that resolves when all the Psets have been removed.
+     *
+     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'psetID' array.
+     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
+     * @throws Will throw an error if no relation is found between the Pset and the model.
      */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
     /**
-     * Utility method to calculate the distance from a point to a line segment.
+     * Creates a new single-value property of type string in the given model.
      *
-     * @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.
+     * @param model - The FragmentsGroup model in which to create the property.
+     * @param type - The type of the property value. Must be a string property type.
+     * @param name - The name of the property.
+     * @param value - The value of the property. Must be a string.
+     *
+     * @returns The newly created single-value property.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
     /**
-     * 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.
+     * Creates a new single-value property of type numeric in the given model.
      *
-     * @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.
+     * @param model - The FragmentsGroup model in which to create the property.
+     * @param type - The type of the property value. Must be a numeric property type.
+     * @param name - The name of the property.
+     * @param value - The value of the property. Must be a number.
+     *
+     * @returns The newly created single-value property.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
+    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
     /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
+     * Creates a new single-value property of type boolean in the given model.
+     *
+     * @param model - The FragmentsGroup model in which to create the property.
+     * @param type - The type of the property value. Must be a boolean property type.
+     * @param name - The name of the property.
+     * @param value - The value of the property. Must be a boolean.
+     *
+     * @returns The newly created single-value property.
      *
-     * @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.
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
+    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
     /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
+     * Removes a property from a Property Set (Pset) in the given model.
      *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
+     * @param model - The FragmentsGroup model from which to remove the property.
+     * @param psetID - The express ID of the Pset from which to remove the property.
+     * @param propID - The express ID of the property to be removed.
+     *
+     * @returns A promise that resolves when the property has been removed.
+     *
+     * @throws Will throw an error if the Pset or the property to be removed are not found in the model.
+     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
      */
-    round(vector: THREE.Vector3): void;
+    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
+    addElementToPset(model: FragmentsGroup, psetID: number, ...expressIDs: number[]): Promise<void>;
     /**
-     * Calculates the volume of a set of fragments.
+     * Adds elements to a Property Set (Pset) in the given model.
      *
-     * @param frags - A map of fragment IDs to their corresponding item IDs.
-     * @returns The total volume of the fragments and the bounding sphere.
+     * @param model - The FragmentsGroup model in which to add the elements.
+     * @param psetID - The express ID of the Pset to which to add the elements.
+     * @param elementID - The express IDs of the elements to be added.
      *
-     * @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.
+     * @returns A promise that resolves when all the elements have been added.
      *
-     * @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.
+     * @throws Will throw an error if the Pset or the elements to be added are not found in the model.
+     * @throws Will throw an error if the Pset to be added to is not of type 'IFCPROPERTYSET'.
+     * @throws Will throw an error if no relation is found between the Pset and the model.
      */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
     /**
-     * Calculates the total volume of a set of meshes.
+     * Saves the changes made to the model to a new IFC file.
      *
-     * @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.
+     * @param model - The FragmentsGroup model from which to save the changes.
+     * @param ifcToSaveOn - The Uint8Array representing the original IFC file.
      *
-     * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
+     * @returns A promise that resolves with the modified IFC data as a Uint8Array.
      *
+     * @throws Will throw an error if any issues occur during the saving process.
      */
-    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 { Disposable, Component, Event, Components } from "../../core";
-/**
- * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs with extra information.
- */
-export interface Classification {
+    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
     /**
-     * A system within the classification.
-     * The key is the system name, and the value is an object representing the classes within the system.
+     * Sets an attribute listener for a specific attribute of an entity in the model.
+     * The listener will trigger an event whenever the attribute's value changes.
+     *
+     * @param model - The FragmentsGroup model in which to set the attribute listener.
+     * @param expressID - The express ID of the entity for which to set the listener.
+     * @param attributeName - The name of the attribute for which to set the listener.
+     *
+     * @returns The event that will be triggered when the attribute's value changes.
+     *
+     * @throws Will throw an error if the entity with the given expressID doesn't exist.
+     * @throws Will throw an error if the attribute is an array or null, and it can't have a listener.
+     * @throws Will throw an error if the attribute has a badly defined handle.
      */
-    [system: string]: {
-        /**
-         * A class within the system.
-         * The key is the class name, and the value is an object containing a map of fragment IDs with extra information.
-         */
-        [className: string]: {
-            map: FRAGS.FragmentIdMap;
-            name: string;
-            id: number | null;
-        };
-    };
+    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
+    private increaseMaxID;
+    private newGUID;
+    private getOwnerHistory;
+    private registerChange;
+    private newSingleProperty;
 }
+import * as WEBIFC from "web-ifc";
+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";
 /**
- * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
+ * 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 Classifier 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: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * A map representing the classification systems.
-     * The key is the system name, and the value is an object representing the classes within the system.
+     * 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.
      */
-    list: Classification;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: 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;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    private indexRelations;
+    private getAttributeIndex;
     /**
-     * Removes a fragment from the classification based on its unique identifier (guid).
-     * This method iterates through all classification systems and classes, and deletes the fragment with the specified guid from the respective group.
+     * Adds a relation map to the model's relations map.
      *
-     * @param guid - The unique identifier of the fragment to be removed.
+     * @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.
      */
-    remove(guid: string): void;
+    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
     /**
-     * Finds and returns fragments based on the provided filter criteria.
-     * If no filter is provided, it returns all fragments.
-     *
-     * @param filter - An optional object containing filter criteria.
-     * The keys of the object represent the classification system names,
-     * and the values are arrays of class names to match.
+     * 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.
      *
-     * @returns A map of fragment GUIDs to their respective express IDs,
-     * where the express IDs are filtered based on the provided filter criteria.
+     * 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.
      *
-     * @throws Will throw an error if the fragments map is malformed.
+     * @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.
      */
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
+    process(model: FragmentsGroup): Promise<RelationsMap>;
     /**
-     * Classifies fragments based on their modelID.
-     *
-     * @param modelID - The unique identifier of the model to classify fragments by.
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the fragments in the provided group,
-     * and classifies them based on their modelID.
-     * The classification is stored in the 'list.models' property,
-     * with the modelID as the key and a map of fragment IDs to their respective express IDs as the value.
+     * 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.
      */
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    processFromWebIfc(ifcApi: WEBIFC.IfcAPI, modelID: number): Promise<RelationsMap>;
     /**
-     * Classifies fragments based on their PredefinedType property.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the properties of the fragments in the provided group,
-     * and classifies them based on their PredefinedType property.
-     * The classification is stored in the 'list.predefinedTypes' property,
-     * with the PredefinedType as the key and a map of fragment IDs to their respective express IDs as the value.
+     * 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.
      *
-     * @throws Will throw an error if the fragment ID is not 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.
      */
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    getEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute): number[] | null;
     /**
-     * Classifies fragments based on their entity type.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on their entity type.
-     * The classification is stored in the 'list.entities' property,
-     * with the entity type as the key and a map of fragment IDs to their respective express IDs as the value.
+     * 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.
      *
-     * @throws Will throw an error if the fragment ID is not found.
+     * @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.
      */
-    byEntity(group: FRAGS.FragmentsGroup): void;
+    serializeRelations(relationMap: RelationsMap): string;
     /**
-     * Classifies fragments based on a specific IFC relationship.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     * @param ifcRel - The IFC relationship number to classify fragments by.
-     * @param systemName - The name of the classification system to store the classification.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on the specified IFC relationship.
-     * The classification is stored in the 'list' property under the specified system name,
-     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
+     * 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.
      *
-     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
+     * @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.
      */
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    serializeModelRelations(model: FragmentsGroup): string | null;
     /**
-     * Classifies fragments based on their spatial structure in the IFC model.
-     *
-     * @param model - The FragmentsGroup containing the fragments to be classified.
-     * @param config - The configuration for the classifier. It includes "useProperties", which is true by default
-     * (if false, the classification will use the expressIDs instead of the names), and "isolate", which will make
-     * the classifier just pick the WEBIFC categories provided.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on their spatial structure in the IFC model.
-     * The classification is stored in the 'list' property under the system name "spatialStructures",
-     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
+     * 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.
      *
-     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
+     * @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.
      */
-    bySpatialStructure(model: FRAGS.FragmentsGroup, config?: {
-        useProperties?: boolean;
-        isolate?: Set<number>;
-    }): Promise<void>;
+    serializeAllRelations(): string;
     /**
-     * Sets the color of the specified fragments.
+     * 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 items - A map of fragment IDs to their respective express IDs.
-     * @param color - The color to set for the fragments.
-     * @param override - A boolean indicating whether to override the existing color of the fragments.
+     * @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.
      *
-     * @remarks
-     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
-     * and sets their color using the 'setColor' method of the FragmentsGroup class.
+     * @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 Will throw an error if the fragment with the specified ID is not found.
+     * @throws An error if the relation name is not a valid relation name.
      */
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    addEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute, ...relIDs: number[]): void;
     /**
-     * Resets the color of the specified fragments to their original color.
-     *
-     * @param items - A map of fragment IDs to their respective express IDs.
+     * 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.
      *
-     * @remarks
-     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
-     * and resets their color using the 'resetColor' method of the FragmentsGroup class.
+     * @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.
      *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
+     * @returns A 'Set' with the expressIDs of the found items.
      */
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
+    getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
 }
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
@@ -1189,6 +1225,12 @@ export declare class BoundingBoxer extends Component implements Disposable {
     addFragmentIdMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
     private static getFragmentBounds;
 }
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
 import * as FRAGS from "@thatopen/fragments";
 import { Components, Component } from "../../core";
 /**
@@ -1210,313 +1252,253 @@ export declare class Hider extends Component {
      *
      * @param visible - The visibility state to set for the fragments.
      * @param items - An optional map of fragment IDs and their corresponding sub-fragment IDs to be affected.
-     * If not provided, all fragments will be affected.
-     *
-     * @returns {void}
-     */
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
-    /**
-     * Isolates fragments within the 3D scene by hiding all other fragments and showing only the specified ones.
-     * It calls the 'set' method twice: first to hide all fragments, and then to show only the specified ones.
-     *
-     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
-     * If not provided, all fragments will be isolated.
-     *
-     * @returns {void}
-     */
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
-}
-import { Component, Disposable, Event, Components } from "../../core";
-/**
- * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
- */
-export declare class Exploder 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: "d260618b-ce88-4c7d-826c-6debb91de3e2";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * The height of the explosion animation.
-     * This property determines the vertical distance by which fragments are moved during the explosion.
-     * Default value is 10.
-     */
-    height: number;
-    /**
-     * The group name used for the explosion animation.
-     * This property specifies the group of fragments that will be affected by the explosion.
-     * Default value is "storeys".
-     */
-    groupName: string;
-    /**
-     * A set of strings representing the exploded items.
-     * This set is used to keep track of which items have been exploded.
-     */
-    list: Set<string>;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets the explosion state of the fragments.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the explosion.
-     *
-     * @remarks
-     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
-     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
-     * If 'active' is false, the fragments are moved back to their original position.
-     *
-     * The method also keeps track of the exploded items using the 'list' set.
-     *
-     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
-     */
-    set(active: boolean): void;
-}
-import { Fragment, FragmentsGroup } from "@thatopen/fragments";
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components, Event, Disposable } 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[];
-    }>;
-    /**
-     * Map containing all loaded fragments.
-     * The key is the fragment's unique identifier, and the value is the fragment itself.
-     */
-    readonly list: Map<string, Fragment>;
-    /**
-     * Map containing all loaded fragment groups.
-     * The key is the group's unique identifier, and the value is the group itself.
-     */
-    readonly groups: Map<string, FragmentsGroup>;
-    baseCoordinationModel: string;
-    baseCoordinationMatrix: THREE.Matrix4;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _loader;
-    /**
-     * Getter for the meshes of all fragments in the FragmentsManager.
-     * It iterates over the fragments in the list and pushes their meshes into an array.
-     * @returns {THREE.Mesh[]} An array of THREE.Mesh objects representing the fragments.
-     */
-    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Dispose of a specific fragment group.
-     * This method removes the group from the groups map, deletes all fragments within the group from the list,
-     * disposes of the group, and triggers the onFragmentsDisposed event.
-     *
-     * @param group - The fragment group to be disposed.
-     */
-    disposeGroup(group: FragmentsGroup): void;
-    /**
-     * Loads a binary file that contain fragment geometry.
-     * @param data - The binary data to load.
-     * @param config - Optional configuration for loading.
-     * @param config.coordinate - Whether to apply coordinate transformation. Default is true.
-     * @param config.properties - Ifc properties to set on the loaded fragments. Not to be used when streaming.
-     * @returns The loaded FragmentsGroup.
-     */
-    load(data: Uint8Array, config?: Partial<{
-        coordinate: boolean;
-        name: string;
-        properties: FRAGS.IfcProperties;
-        relationsMap: RelationsMap;
-    }>): FragmentsGroup;
-    /**
-     * Export the specified fragmentsgroup to binary data.
-     * @param group - the fragments group to be exported.
-     * @returns the exported data as binary buffer.
-     */
-    export(group: FragmentsGroup): Uint8Array;
-    /**
-     * Gets a map of model IDs to sets of express IDs for the given fragment ID map.
-     * @param fragmentIdMap - A map of fragment IDs to their corresponding express IDs.
-     * @returns A map of model IDs to sets of express IDs.
-     */
-    getModelIdMap(fragmentIdMap: FRAGS.FragmentIdMap): {
-        [modelID: string]: Set<number>;
-    };
-    /**
-     * Converts a map of model IDs to sets of express IDs to a fragment ID map.
-     * @param modelIdMap - A map of model IDs to their corresponding express IDs.
-     * @returns A fragment ID map.
-     * @remarks
-     * This method iterates through the provided model ID map, retrieves the corresponding model from the 'groups' map,
-     * and then calls the 'getFragmentMap' method of the model to obtain a fragment ID map for the given express IDs.
-     * The fragment ID maps are then merged into a single map and returned.
-     * If a model with a given ID is not found in the 'groups' map, the method skips that model and continues with the next one.
-     */
-    modelIdToFragmentIdMap(modelIdMap: {
-        [modelID: string]: Set<number>;
-    }): FRAGS.FragmentIdMap;
-    /**
-     * Applies coordinate transformation to the provided models.
-     * If no models are provided, all groups are used.
-     * The first model in the list becomes the base model for coordinate transformation.
-     * All other models are then transformed to match the base model's coordinate system.
+     * If not provided, all fragments will be affected.
      *
-     * @param models - The models to apply coordinate transformation to.
-     * If not provided, all models are used.
+     * @returns {void}
      */
-    coordinate(models?: FragmentsGroup[]): void;
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
     /**
-     * Applies the base coordinate system to the provided object.
-     *
-     * This function takes an object and its original coordinate system as input.
-     * It then inverts the original coordinate system and applies the base coordinate system
-     * to the object. This ensures that the object's position, rotation, and scale are
-     * transformed to match the base coordinate system (which is taken from the first model loaded).
+     * Isolates fragments within the 3D scene by hiding all other fragments and showing only the specified ones.
+     * It calls the 'set' method twice: first to hide all fragments, and then to show only the specified ones.
      *
-     * @param object - The object to which the base coordinate system will be applied.
-     * This should be an instance of THREE.Object3D.
+     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
+     * If not provided, all fragments will be isolated.
      *
-     * @param originalCoordinateSystem - The original coordinate system of the object.
-     * This should be a THREE.Matrix4 representing the object's transformation matrix.
+     * @returns {void}
      */
-    applyBaseCoordinateSystem(object: THREE.Object3D | THREE.Vector3, originalCoordinateSystem: THREE.Matrix4): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
 }
-import * as WEBIFC from "web-ifc";
+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 THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
+import { Disposable, Component, Event, Components } 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).
+ * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs with extra information.
  */
-export declare class IfcLoader extends Component implements Disposable {
+export interface Classification {
+    /**
+     * A system within the classification.
+     * The key is the system name, and the value is an object representing the classes within the system.
+     */
+    [system: string]: {
+        /**
+         * A class within the system.
+         * The key is the class name, and the value is an object containing a map of fragment IDs with extra information.
+         */
+        [className: string]: {
+            map: FRAGS.FragmentIdMap;
+            name: string;
+            id: number | null;
+        };
+    };
+}
+/**
+ * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
+ */
+export declare class Classifier 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";
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * A map representing the classification systems.
+     * The key is the system name, and the value is an object representing the classes within the system.
+     */
+    list: Classification;
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    readonly onDisposed: Event<unknown>;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * An event triggered when the IFC file starts loading.
+     * Removes a fragment from the classification based on its unique identifier (guid).
+     * This method iterates through all classification systems and classes, and deletes the fragment with the specified guid from the respective group.
+     *
+     * @param guid - The unique identifier of the fragment to be removed.
      */
-    readonly onIfcStartedLoading: Event<void>;
+    remove(guid: string): void;
     /**
-     * An event triggered when the setup process is completed.
+     * Finds and returns fragments based on the provided filter criteria.
+     * If no filter is provided, it returns all fragments.
+     *
+     * @param filter - An optional object containing filter criteria.
+     * The keys of the object represent the classification system names,
+     * and the values are arrays of class names to match.
+     *
+     * @returns A map of fragment GUIDs to their respective express IDs,
+     * where the express IDs are filtered based on the provided filter criteria.
+     *
+     * @throws Will throw an error if the fragments map is malformed.
      */
-    readonly onSetup: Event<void>;
+    find(filter?: {
+        [name: string]: string[];
+    }): FRAGS.FragmentIdMap;
     /**
-     * The settings for the IfcLoader.
-     * It includes options for excluding categories, setting WASM paths, and more.
+     * Classifies fragments based on their modelID.
+     *
+     * @param modelID - The unique identifier of the model to classify fragments by.
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the fragments in the provided group,
+     * and classifies them based on their modelID.
+     * The classification is stored in the 'list.models' property,
+     * with the modelID as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
      */
-    settings: IfcFragmentSettings;
+    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
     /**
-     * The instance of the Web-IFC library used for handling IFC data.
+     * Classifies fragments based on their PredefinedType property.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the properties of the fragments in the provided group,
+     * and classifies them based on their PredefinedType property.
+     * The classification is stored in the 'list.predefinedTypes' property,
+     * with the PredefinedType as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found.
      */
-    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;
+    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
     /**
-     * Sets up the IfcLoader component with the provided configuration.
+     * Classifies fragments based on their entity type.
      *
-     * @param config - Optional configuration settings for the IfcLoader.
-     * If not provided, the existing settings will be used.
+     * @param group - The FragmentsGroup containing the fragments to be classified.
      *
-     * @returns A Promise that resolves when the setup process is completed.
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their entity type.
+     * The classification is stored in the 'list.entities' property,
+     * with the entity type as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found.
+     */
+    byEntity(group: FRAGS.FragmentsGroup): void;
+    /**
+     * Classifies fragments based on a specific IFC relationship.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     * @param ifcRel - The IFC relationship number to classify fragments by.
+     * @param systemName - The name of the classification system to store the classification.
      *
      * @remarks
-     * If the 'autoSetWasm' option is enabled in the configuration,
-     * the method will automatically set the WASM paths for the Web-IFC library.
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on the specified IFC relationship.
+     * The classification is stored in the 'list' property under the specified system name,
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = new IfcLoader(components);
-     * await ifcLoader.setup({ autoSetWasm: true });
-     * '''
+     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
      */
-    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
     /**
-     * Loads an IFC file and processes it for 3D visualization.
+     * Classifies fragments based on their spatial structure in the IFC model.
      *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @param coordinate - Optional boolean indicating whether to coordinate the loaded IFC data. Default is true.
+     * @param model - The FragmentsGroup containing the fragments to be classified.
+     * @param config - The configuration for the classifier. It includes "useProperties", which is true by default
+     * (if false, the classification will use the expressIDs instead of the names), and "isolate", which will make
+     * the classifier just pick the WEBIFC categories provided.
      *
-     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their spatial structure in the IFC model.
+     * The classification is stored in the 'list' property under the system name "spatialStructures",
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * const group = await ifcLoader.load(ifcData);
-     * '''
+     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
      */
-    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
+    bySpatialStructure(model: FRAGS.FragmentsGroup, config?: {
+        useProperties?: boolean;
+        isolate?: Set<number>;
+    }): Promise<void>;
     /**
-     * Reads an IFC file and initializes the Web-IFC library.
+     * Sets the color of the specified fragments.
      *
-     * @param data - The Uint8Array containing the IFC file data.
+     * @param items - A map of fragment IDs to their respective express IDs.
+     * @param color - The color to set for the fragments.
+     * @param override - A boolean indicating whether to override the existing color of the fragments.
      *
-     * @returns A Promise that resolves when the IFC file is opened and initialized.
+     * @remarks
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and sets their color using the 'setColor' method of the FragmentsGroup class.
+     *
+     * @throws Will throw an error if the fragment with the specified ID is not found.
+     */
+    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    /**
+     * Resets the color of the specified fragments to their original color.
+     *
+     * @param items - A map of fragment IDs to their respective express IDs.
      *
      * @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.
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and resets their color using the 'resetColor' method of the FragmentsGroup class.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * await ifcLoader.readIfcFile(ifcData);
-     * '''
+     * @throws Will throw an error if the fragment with the specified ID is not found.
+     */
+    resetColor(items: FRAGS.FragmentIdMap): void;
+    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
+}
+import { Component, Disposable, Event, Components } from "../../core";
+/**
+ * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
+ */
+export declare class Exploder 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: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * The height of the explosion animation.
+     * This property determines the vertical distance by which fragments are moved during the explosion.
+     * Default value is 10.
+     */
+    height: number;
+    /**
+     * The group name used for the explosion animation.
+     * This property specifies the group of fragments that will be affected by the explosion.
+     * Default value is "storeys".
+     */
+    groupName: string;
+    /**
+     * A set of strings representing the exploded items.
+     * This set is used to keep track of which items have been exploded.
      */
-    readIfcFile(data: Uint8Array): Promise<number>;
+    list: Set<string>;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * 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.
+     * Sets the explosion state of the fragments.
+     *
+     * @param active - A boolean indicating whether to activate or deactivate the explosion.
      *
      * @remarks
-     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
+     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
+     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
+     * If 'active' is false, the fragments are moved back to their original position.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * ifcLoader.cleanUp();
-     * '''
+     * The method also keeps track of the exploded items using the 'list' set.
+     *
+     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
      */
-    cleanUp(): void;
-    private getAllGeometries;
-    private getMesh;
-    private getGeometry;
-    private autoSetWasm;
+    set(active: boolean): void;
 }
 import * as WEBIFC from "web-ifc";
 import { Components, Disposable, Event, Component } from "../../core";
@@ -1617,513 +1599,549 @@ export declare class IfcGeometryTiler extends Component implements Disposable {
     private streamGeometries;
 }
 import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../core";
-import { PropertiesStreamingSettings } from "./src";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
 /**
- * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
+ * 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 IfcPropertiesTiler 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: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
-    /**
-     * An event that is triggered when properties are streamed from the IFC file.
-     * The event provides the type of the IFC entity and the corresponding data.
-     */
-    readonly onPropertiesStreamed: AsyncEvent<{
-        type: number;
-        data: {
-            [id: number]: any;
-        };
-    }>;
+    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * An event that is triggered to indicate the progress of the streaming process.
-     * The event provides a number between 0 and 1 representing the progress percentage.
+     * An event triggered when the IFC file starts loading.
      */
-    readonly onProgress: AsyncEvent<number>;
+    readonly onIfcStartedLoading: Event<void>;
     /**
-     * An event that is triggered when indices are streamed from the IFC file.
-     * The event provides a map of indices, where the key is the entity type and the value is another map of indices.
+     * An event triggered when the setup process is completed.
      */
-    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    readonly onSetup: Event<void>;
     /**
-     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
+     * The settings for the IfcLoader.
+     * It includes options for excluding categories, setting WASM paths, and more.
      */
-    settings: PropertiesStreamingSettings;
+    settings: IfcFragmentSettings;
     /**
-     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
+     * 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(): Promise<void>;
+    dispose(): void;
     /**
-     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
+     * Sets up the IfcLoader component with the provided configuration.
      *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @returns A Promise that resolves when the streaming process is complete.
+     * @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 });
+     * '''
      */
-    streamFromBuffer(data: Uint8Array): Promise<void>;
+    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
     /**
-     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
+     * Loads an IFC file and processes it for 3D visualization.
      *
-     * @param loadCallback - A callback function that loads the IFC file data.
-     * @returns A Promise that resolves when the streaming process is complete.
+     * @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);
+     * '''
      */
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllProperties;
-    private cleanUp;
-}
-import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
- */
-export declare class IfcJsonExporter extends Component {
+    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * 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);
+     * '''
      */
-    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    readIfcFile(data: Uint8Array): Promise<number>;
     /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
+     * 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();
+     * '''
      */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+    cleanUp(): void;
+    private getAllGeometries;
+    private getMesh;
+    private getGeometry;
+    private autoSetWasm;
 }
-import * as WEBIFC from "web-ifc";
-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 { Fragment, FragmentsGroup } from "@thatopen/fragments";
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components, Event, Disposable } from "../../core";
+import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
 /**
- * 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).
+ * 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 IfcRelationsIndexer extends Component implements Disposable {
+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: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    readonly onDisposed: Event<unknown>;
     /**
-     * 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.
+     * Event triggered when fragments are loaded.
      */
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
+    readonly onFragmentsLoaded: Event<FragmentsGroup>;
     /**
-     * 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.
+     * Event triggered when fragments are disposed.
      */
-    readonly relationMaps: ModelsRelationMap;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _relToAttributesMap;
-    private _inverseAttributes;
-    private _ifcRels;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    private indexRelations;
-    private getAttributeIndex;
+    readonly onFragmentsDisposed: Event<{
+        groupID: string;
+        fragmentIDs: string[];
+    }>;
     /**
-     * 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.
+     * Map containing all loaded fragments.
+     * The key is the fragment's unique identifier, and the value is the fragment itself.
      */
-    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.
+    readonly list: Map<string, Fragment>;
+    /**
+     * Map containing all loaded fragment groups.
+     * The key is the group's unique identifier, and the value is the group itself.
      */
-    process(model: FragmentsGroup): Promise<RelationsMap>;
+    readonly groups: Map<string, FragmentsGroup>;
+    baseCoordinationModel: string;
+    baseCoordinationMatrix: THREE.Matrix4;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    private _loader;
     /**
-     * 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.
+     * Getter for the meshes of all fragments in the FragmentsManager.
+     * It iterates over the fragments in the list and pushes their meshes into an array.
+     * @returns {THREE.Mesh[]} An array of THREE.Mesh objects representing the fragments.
      */
-    processFromWebIfc(ifcApi: WEBIFC.IfcAPI, modelID: number): Promise<RelationsMap>;
+    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * 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.
+     * Dispose of a specific fragment group.
+     * This method removes the group from the groups map, deletes all fragments within the group from the list,
+     * disposes of the group, and triggers the onFragmentsDisposed event.
      *
-     * @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.
+     * @param group - The fragment group to be disposed.
      */
-    getEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute): number[] | null;
+    disposeGroup(group: FragmentsGroup): void;
     /**
-     * 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.
+     * Loads a binary file that contain fragment geometry.
+     * @param data - The binary data to load.
+     * @param config - Optional configuration for loading.
+     * @param config.coordinate - Whether to apply coordinate transformation. Default is true.
+     * @param config.properties - Ifc properties to set on the loaded fragments. Not to be used when streaming.
+     * @returns The loaded FragmentsGroup.
      */
-    serializeRelations(relationMap: RelationsMap): string;
+    load(data: Uint8Array, config?: Partial<{
+        coordinate: boolean;
+        name: string;
+        properties: FRAGS.IfcProperties;
+        relationsMap: RelationsMap;
+    }>): FragmentsGroup;
     /**
-     * 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.
+     * Export the specified fragmentsgroup to binary data.
+     * @param group - the fragments group to be exported.
+     * @returns the exported data as binary buffer.
      */
-    serializeModelRelations(model: FragmentsGroup): string | null;
+    export(group: FragmentsGroup): Uint8Array;
     /**
-     * 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.
+     * Gets a map of model IDs to sets of express IDs for the given fragment ID map.
+     * @param fragmentIdMap - A map of fragment IDs to their corresponding express IDs.
+     * @returns A map of model IDs to sets of express IDs.
      */
-    serializeAllRelations(): string;
+    getModelIdMap(fragmentIdMap: FRAGS.FragmentIdMap): {
+        [modelID: string]: Set<number>;
+    };
     /**
-     * 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.
+     * Converts a map of model IDs to sets of express IDs to a fragment ID map.
+     * @param modelIdMap - A map of model IDs to their corresponding express IDs.
+     * @returns A fragment ID map.
+     * @remarks
+     * This method iterates through the provided model ID map, retrieves the corresponding model from the 'groups' map,
+     * and then calls the 'getFragmentMap' method of the model to obtain a fragment ID map for the given express IDs.
+     * The fragment ID maps are then merged into a single map and returned.
+     * If a model with a given ID is not found in the 'groups' map, the method skips that model and continues with the next one.
      */
-    getRelationsMapFromJSON(json: string): RelationsMap;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    modelIdToFragmentIdMap(modelIdMap: {
+        [modelID: string]: Set<number>;
+    }): FRAGS.FragmentIdMap;
     /**
-     * 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.
+     * Applies coordinate transformation to the provided models.
+     * If no models are provided, all groups are used.
+     * The first model in the list becomes the base model for coordinate transformation.
+     * All other models are then transformed to match the base model's coordinate system.
      *
-     * @throws An error if the relation name is not a valid relation name.
+     * @param models - The models to apply coordinate transformation to.
+     * If not provided, all models are used.
      */
-    addEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute, ...relIDs: number[]): void;
+    coordinate(models?: FragmentsGroup[]): 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.
+     * Applies the base coordinate system to the provided object.
      *
-     * @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.
+     * This function takes an object and its original coordinate system as input.
+     * It then inverts the original coordinate system and applies the base coordinate system
+     * to the object. This ensures that the object's position, rotation, and scale are
+     * transformed to match the base coordinate system (which is taken from the first model loaded).
      *
-     * @returns A 'Set' with the expressIDs of the found items.
+     * @param object - The object to which the base coordinate system will be applied.
+     * This should be an instance of THREE.Object3D.
+     *
+     * @param originalCoordinateSystem - The original coordinate system of the object.
+     * This should be a THREE.Matrix4 representing the object's transformation matrix.
      */
-    getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
+    applyBaseCoordinateSystem(object: THREE.Object3D | THREE.Vector3, originalCoordinateSystem: THREE.Matrix4): void;
 }
 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 { AsyncEvent, Component, Disposable, Event } from "../../core";
+import { PropertiesStreamingSettings } from "./src";
 /**
- * Component to manage and edit properties and Psets in IFC files.
+ * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
  */
-export declare class IfcPropertiesManager extends Component implements Disposable {
+export declare class IfcPropertiesTiler 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: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    /**
+     * An event that is triggered when properties are streamed from the IFC file.
+     * The event provides the type of the IFC entity and the corresponding data.
+     */
+    readonly onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
+        };
+    }>;
+    /**
+     * An event that is triggered to indicate the progress of the streaming process.
+     * The event provides a number between 0 and 1 representing the progress percentage.
+     */
+    readonly onProgress: AsyncEvent<number>;
+    /**
+     * An event that is triggered when indices are streamed from the IFC file.
+     * The event provides a map of indices, where the key is the entity type and the value is another map of indices.
+     */
+    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * Event triggered when a file is requested for export.
+     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
      */
-    readonly onRequestFile: Event<unknown>;
+    settings: PropertiesStreamingSettings;
     /**
-     * ArrayBuffer containing the IFC data to be exported.
+     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
      */
-    ifcToExport: ArrayBuffer | null;
+    webIfc: WEBIFC.IfcAPI;
+    /** {@link Disposable.dispose} */
+    dispose(): Promise<void>;
     /**
-     * Event triggered when an element is added to a Pset.
+     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
      */
-    readonly onElementToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        elementID: number;
-    }>;
+    streamFromBuffer(data: Uint8Array): Promise<void>;
     /**
-     * Event triggered when a property is added to a Pset.
+     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
+     *
+     * @param loadCallback - A callback function that loads the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
      */
-    readonly onPropToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        propID: number;
-    }>;
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private cleanUp;
+}
+import * as THREE from "three";
+import { Component, Components, Disposable, Event, World } from "../core";
+/**
+ * Configuration interface for the VertexPicker component.
+ */
+export interface VertexPickerConfig {
     /**
-     * Event triggered when a Pset is removed.
+     * 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.
      */
-    readonly onPsetRemoved: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-    }>;
+    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>;
     /**
-     * Event triggered when data in the model changes.
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
      */
-    readonly onDataChanged: Event<{
-        model: FragmentsGroup;
-        expressID: number;
-    }>;
+    readonly onVertexFound: Event<THREE.Vector3>;
     /**
-     * Configuration for the WebAssembly module.
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
      */
-    wasm: {
-        path: string;
-        absolute: boolean;
-    };
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    readonly onVertexLost: Event<THREE.Vector3>;
     /**
-     * Map of attribute listeners.
+     * An event that is triggered when the picker is enabled or disabled
      */
-    attributeListeners: AttributeListener;
+    readonly onEnabled: Event<boolean>;
     /**
-     * The currently selected model.
+     * A reference to the Components instance associated with this VertexPicker.
      */
-    selectedModel?: FragmentsGroup;
+    components: Components;
     /**
-     * Map of changed entities in the model.
+     * 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.
      */
-    changeMap: ChangeMap;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    workingPlane: THREE.Plane | null;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
     /**
-     * Static method to retrieve the IFC schema from a given model.
+     * 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 model - The FragmentsGroup model from which to retrieve the IFC schema.
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @returns The IFC schema associated with the given model.
+     * @param value - The new enabled state.
      */
-    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
+    set enabled(value: boolean);
     /**
-     * Method to set properties data in the model.
-     *
-     * @param model - The FragmentsGroup model in which to set the properties.
-     * @param dataToSave - An array of objects representing the properties to be saved.
-     * Each object must have an 'expressID' property, which is the express ID of the entity in the model.
-     * The rest of the properties will be set as the properties of the entity.
-     *
-     * @returns A promise that resolves when all the properties have been set.
+     * Gets the current enabled state of the VertexPicker.
      *
-     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'dataToSave' array.
+     * @returns The current enabled state.
      */
-    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
+    get enabled(): boolean;
     /**
-     * Creates a new Property Set (Pset) in the given model.
-     *
-     * @param model - The FragmentsGroup model in which to create the Pset.
-     * @param name - The name of the Pset.
-     * @param description - (Optional) The description of the Pset.
+     * Sets the configuration for the VertexPicker component.
      *
-     * @returns A promise that resolves with an object containing the newly created Pset and its relation.
+     * @param value - A Partial object containing the configuration properties to update.
+     * The properties not provided in the value object will retain their current values.
      *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * @example
+     * '''typescript
+     * vertexPicker.config = {
+     *   snapDistance: 0.5,
+     *   showOnlyVertex: true,
+     * };
+     * '''
      */
-    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
-        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
-        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
-    }>;
+    set config(value: Partial<VertexPickerConfig>);
     /**
-     * Removes a Property Set (Pset) from the given model.
-     *
-     * @param model - The FragmentsGroup model from which to remove the Pset.
-     * @param psetID - The express IDs of the Psets to be removed.
+     * Gets the current configuration for the VertexPicker component.
      *
-     * @returns A promise that resolves when all the Psets have been removed.
+     * @returns A copy of the current VertexPickerConfig object.
      *
-     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'psetID' array.
-     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
-     * @throws Will throw an error if no relation is found between the Pset and the model.
+     * @example
+     * '''typescript
+     * const currentConfig = vertexPicker.config;
+     * console.log(currentConfig.snapDistance); // Output: 0.25
+     * '''
      */
-    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Creates a new single-value property of type string in the given model.
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
      *
-     * @param model - The FragmentsGroup model in which to create the property.
-     * @param type - The type of the property value. Must be a string property type.
-     * @param name - The name of the property.
-     * @param value - The value of the property. Must be a string.
+     * @param world - The World instance to use for raycasting.
      *
-     * @returns The newly created single-value property.
+     * @returns The current picked point, or null if no point is picked.
      *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * @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'.
      */
-    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+/**
+ * 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;
+};
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Represents an edge measurement result.
+ */
+export interface MeasureEdge {
     /**
-     * Creates a new single-value property of type numeric in the given model.
-     *
-     * @param model - The FragmentsGroup model in which to create the property.
-     * @param type - The type of the property value. Must be a numeric property type.
-     * @param name - The name of the property.
-     * @param value - The value of the property. Must be a number.
-     *
-     * @returns The newly created single-value property.
-     *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * The distance between the two points of the edge.
      */
-    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    distance: number;
     /**
-     * Creates a new single-value property of type boolean in the given model.
-     *
-     * @param model - The FragmentsGroup model in which to create the property.
-     * @param type - The type of the property value. Must be a boolean property type.
-     * @param name - The name of the property.
-     * @param value - The value of the property. Must be a boolean.
-     *
-     * @returns The newly created single-value property.
-     *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * The two points that define the edge.
      */
-    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    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 {
     /**
-     * Removes a property from a Property Set (Pset) in the given model.
-     *
-     * @param model - The FragmentsGroup model from which to remove the property.
-     * @param psetID - The express ID of the Pset from which to remove the property.
-     * @param propID - The express ID of the property to be removed.
-     *
-     * @returns A promise that resolves when the property has been removed.
-     *
-     * @throws Will throw an error if the Pset or the property to be removed are not found in the model.
-     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
-    addElementToPset(model: FragmentsGroup, psetID: number, ...expressIDs: number[]): Promise<void>;
+    static uuid: string;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
     /**
-     * Adds elements to a Property Set (Pset) in the given model.
+     * Utility method to calculate the distance from a point to a line segment.
      *
-     * @param model - The FragmentsGroup model in which to add the elements.
-     * @param psetID - The express ID of the Pset to which to add the elements.
-     * @param elementID - The express IDs of the elements to be added.
+     * @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.
      *
-     * @returns A promise that resolves when all the elements have been added.
+     * @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.
      *
-     * @throws Will throw an error if the Pset or the elements to be added are not found in the model.
-     * @throws Will throw an error if the Pset to be added to is not of type 'IFCPROPERTYSET'.
-     * @throws Will throw an error if no relation is found between the Pset and the model.
+     * @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.
      */
-    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
+    round(vector: THREE.Vector3): void;
     /**
-     * Saves the changes made to the model to a new IFC file.
+     * Calculates the volume of a set of fragments.
      *
-     * @param model - The FragmentsGroup model from which to save the changes.
-     * @param ifcToSaveOn - The Uint8Array representing the original IFC file.
+     * @param frags - A map of fragment IDs to their corresponding item IDs.
+     * @returns The total volume of the fragments and the bounding sphere.
      *
-     * @returns A promise that resolves with the modified IFC data as a Uint8Array.
+     * @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 any issues occur during the saving process.
+     * @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.
      */
-    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
+    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
     /**
-     * Sets an attribute listener for a specific attribute of an entity in the model.
-     * The listener will trigger an event whenever the attribute's value changes.
+     * Calculates the total volume of a set of meshes.
      *
-     * @param model - The FragmentsGroup model in which to set the attribute listener.
-     * @param expressID - The express ID of the entity for which to set the listener.
-     * @param attributeName - The name of the attribute for which to set the listener.
+     * @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.
      *
-     * @returns The event that will be triggered when the attribute's value changes.
+     * @remarks
+     * This method calculates the volume of each mesh in the provided array and returns the total volume
+     * and its bounding sphere.
      *
-     * @throws Will throw an error if the entity with the given expressID doesn't exist.
-     * @throws Will throw an error if the attribute is an array or null, and it can't have a listener.
-     * @throws Will throw an error if the attribute has a badly defined handle.
      */
-    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
-    private increaseMaxID;
-    private newGUID;
-    private getOwnerHistory;
-    private registerChange;
-    private newSingleProperty;
+    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
+    private getFaceData;
+    private getVolumeOfMesh;
+    private getSignedVolumeOfTriangle;
+}
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
 }
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
@@ -2215,84 +2233,6 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     private updatePlanes;
 }
 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";
-import { IfcItemsCategories } from "../../../ifc";
-export declare class SpatialStructure {
-    itemsByFloor: IfcItemsCategories;
-    private _units;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    cleanUp(): void;
-}
-/**
- * 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 WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}
-import * as WEBIFC from "web-ifc";
-/** Configuration of the IFC-fragment conversion. */
-export declare class IfcFragmentSettings {
-    /** Whether to extract the IFC properties into a JSON. */
-    includeProperties: boolean;
-    /**
-     * Generate the geometry for categories that are not included by default,
-     * like IFCSPACE.
-     */
-    optionalCategories: number[];
-    /** Whether to use the coordination data coming from the IFC files. */
-    coordinate: boolean;
-    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    wasm: {
-        path: string;
-        absolute: boolean;
-        logLevel?: WEBIFC.LogLevel;
-    };
-    /** List of categories that won't be converted to fragments. */
-    excludedCategories: Set<number>;
-    /** Whether to save the absolute location of all IFC items. */
-    saveLocations: boolean;
-    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    webIfc: WEBIFC.LoaderSettings;
-    /**
-     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * If set to true, the path will be set to the default path of the WASM file.
-     * If set to false, the path must be provided manually in the 'wasm.path' property.
-     * Default value is true.
-     */
-    autoSetWasm: boolean;
-    /**
-     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
-     * If set to null, the default file location handler will be used.
-     *
-     * @param url - The URL of the file to locate.
-     * @returns The absolute path of the file.
-     */
-    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
-}
-/**
- * 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;
-};
-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<{
@@ -2314,213 +2254,120 @@ export declare class IfcPropertiesUtils {
         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 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 { 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;
-}
-/**
- * A Set of unique numbers representing different types of IFC geometries.
- */
-export declare const GeometryTypes: Set<number>;
-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;
-}
-/**
- * The projection system of the camera.
- */
-export type CameraProjection = "Perspective" | "Orthographic";
-/**
- * The extensible list of supported navigation modes.
- */
-export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
+    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>>>;
+}
 /**
- * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ * 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 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 { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
+export declare const IfcCategoryMap: {
+    [key: number]: string;
+};
 /**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ * A Set of unique numbers representing different types of IFC geometries.
  */
-export declare class ProjectionManager {
+export declare const GeometryTypes: Set<number>;
+import { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<number, {
+    forRelating: InverseAttribute;
+    forRelated: InverseAttribute;
+}>;
+import * as WEBIFC from "web-ifc";
+/** Configuration of the IFC-fragment conversion. */
+export declare class IfcFragmentSettings {
+    /** Whether to extract the IFC properties into a JSON. */
+    includeProperties: boolean;
     /**
-     * Event that fires when the {@link CameraProjection} changes.
+     * Generate the geometry for categories that are not included by default,
+     * like IFCSPACE.
      */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+    optionalCategories: number[];
+    /** Whether to use the coordination data coming from the IFC files. */
+    coordinate: boolean;
+    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    wasm: {
+        path: string;
+        absolute: boolean;
+        logLevel?: WEBIFC.LogLevel;
+    };
+    /** List of categories that won't be converted to fragments. */
+    excludedCategories: Set<number>;
+    /** Whether to save the absolute location of all IFC items. */
+    saveLocations: boolean;
+    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    webIfc: WEBIFC.LoaderSettings;
     /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
+     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * If set to true, the path will be set to the default path of the WASM file.
+     * If set to false, the path must be provided manually in the 'wasm.path' property.
+     * Default value is true.
      */
-    current: CameraProjection;
+    autoSetWasm: boolean;
     /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
+     * If set to null, the default file location handler will be used.
+     *
+     * @param url - The URL of the file to locate.
+     * @returns The absolute path of the file.
      */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    constructor(camera: OrthoPerspectiveCamera);
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+/**
+ * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
+ */
+export declare class Event<T> {
     /**
-     * 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.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    set(projection: CameraProjection): Promise<void>;
+    add(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
     /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
      */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
+    remove(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => void;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
 }
-import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
-import { Components } from "../../Components";
 /**
- * Base class of the library. Useful for finding out the interfaces something implements.
+ * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
  */
-export declare abstract class Base {
-    components: Components;
-    constructor(components: Components);
-    /** Whether is component is {@link Disposable}. */
-    isDisposeable: () => this is Disposable;
-    /** Whether is component is {@link Resizeable}. */
-    isResizeable: () => this is Resizeable;
-    /** Whether is component is {@link Updateable}. */
-    isUpdateable: () => this is Updateable;
-    /** Whether is component is {@link Hideable}. */
-    isHideable: () => this is Hideable;
-    /** Whether is component is {@link Configurable}. */
-    isConfigurable: () => this is Configurable<any>;
+export declare class AsyncEvent<T> {
+    /**
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
+     */
+    add(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /**
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
+     */
+    remove(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => Promise<void>;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
 }
 import * as THREE from "three";
 import CameraControls from "camera-controls";
@@ -2630,67 +2477,6 @@ export interface CameraControllable {
      */
     controls: CameraControls;
 }
-import { InverseAttribute } from "./types";
-export declare const relToAttributesMap: Map<number, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;
-/**
- * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
- */
-export declare class Event<T> {
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
-     */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
-     */
-    remove(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => void;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { BaseWorldItem } from "./base-world-item";
-import { CameraControllable } from "./interfaces";
-/**
- * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
- */
-export declare abstract class BaseCamera extends BaseWorldItem {
-    /**
-     * Whether the camera is enabled or not.
-     */
-    abstract enabled: boolean;
-    /**
-     * The Three.js camera instance.
-     */
-    abstract three: THREE.Camera;
-    /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
-     */
-    abstract controls?: CameraControls;
-    /**
-     * Checks whether the instance is {@link CameraControllable}.
-     *
-     * @returns True if the instance is controllable, false otherwise.
-     */
-    hasCameraControls: () => this is CameraControllable;
-}
 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.
@@ -2702,58 +2488,54 @@ export declare abstract class Component extends Base {
      * dimensions, while a disabled camera will stop moving. A disabled component
      * will not be updated automatically each frame.
      */
-    abstract enabled: boolean;
-}
-/**
- * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
- */
-export declare class AsyncEvent<T> {
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
-     */
-    add(handler: T extends void ? {
-        (): Promise<void>;
-    } : {
-        (data: T): Promise<void>;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
-     */
-    remove(handler: T extends void ? {
-        (): Promise<void>;
-    } : {
-        (data: T): Promise<void>;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => Promise<void>;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}
-import { Base } from "./base";
-import { World } from "./world";
-import { Event } from "./event";
-import { Components } from "../../Components";
+    abstract enabled: boolean;
+}
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { BaseWorldItem } from "./base-world-item";
+import { CameraControllable } from "./interfaces";
 /**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
+ * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
  */
-export declare abstract class BaseWorldItem extends Base {
-    readonly worlds: Map<string, World>;
+export declare abstract class BaseCamera extends BaseWorldItem {
     /**
-     * Event that is triggered when a world is added or removed from the 'worlds' map.
-     * The event payload contains the world instance and the action ("added" or "removed").
+     * Whether the camera is enabled or not.
      */
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
-    }>;
+    abstract enabled: boolean;
     /**
-     * The current world this item is associated with. It can be null if no world is currently active.
+     * The Three.js camera instance.
      */
-    currentWorld: World | null;
-    protected constructor(components: Components);
+    abstract three: THREE.Camera;
+    /**
+     * Optional CameraControls instance for controlling the camera.
+     * This property is only available if the camera is controllable.
+     */
+    abstract controls?: CameraControls;
+    /**
+     * Checks whether the instance is {@link CameraControllable}.
+     *
+     * @returns True if the instance is controllable, false otherwise.
+     */
+    hasCameraControls: () => this is CameraControllable;
+}
+import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
+import { Components } from "../../Components";
+/**
+ * Base class of the library. Useful for finding out the interfaces something implements.
+ */
+export declare abstract class Base {
+    components: Components;
+    constructor(components: Components);
+    /** Whether is component is {@link Disposable}. */
+    isDisposeable: () => this is Disposable;
+    /** Whether is component is {@link Resizeable}. */
+    isResizeable: () => this is Resizeable;
+    /** Whether is component is {@link Updateable}. */
+    isUpdateable: () => this is Updateable;
+    /** Whether is component is {@link Hideable}. */
+    isHideable: () => this is Hideable;
+    /** Whether is component is {@link Configurable}. */
+    isConfigurable: () => this is Configurable<any>;
 }
 import * as THREE from "three";
 import { Vector2 } from "three";
@@ -2820,6 +2602,42 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
      */
     setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }
+import { Base } from "./base";
+import { World } from "./world";
+import { Event } from "./event";
+import { Components } from "../../Components";
+/**
+ * One of the elements that make a world. It can be either a scene, a camera or a renderer.
+ */
+export declare abstract class BaseWorldItem extends Base {
+    readonly worlds: Map<string, World>;
+    /**
+     * Event that is triggered when a world is added or removed from the 'worlds' map.
+     * The event payload contains the world instance and the action ("added" or "removed").
+     */
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
+    }>;
+    /**
+     * The current world this item is associated with. It can be null if no world is currently active.
+     */
+    currentWorld: World | null;
+    protected constructor(components: Components);
+}
+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";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
+}
 import * as THREE from "three";
 import { Disposable } from "./interfaces";
 import { Event } from "./event";
@@ -2841,6 +2659,99 @@ export declare abstract class BaseScene extends BaseWorldItem implements Disposa
     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 * 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 { 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.
@@ -2916,117 +2827,151 @@ export declare class SimpleRaycaster implements Disposable {
     private filterClippingPlanes;
 }
 import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+import { Components } from "../../Components";
+import { AsyncEvent, Event, World } 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.
+ * Settings to configure the CullerRenderer.
  */
-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;
+export interface CullerRendererSettings {
     /**
-     * A unique identifier for the world.
+     * Interval in milliseconds at which the visibility check should be performed.
+     * Default value is 1000.
      */
-    uuid: string;
+    updateInterval?: number;
     /**
-     * An optional name for the world.
+     * Width of the render target used for visibility checks.
+     * Default value is 512.
      */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
+    width?: number;
     /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
+     * Height of the render target used for visibility checks.
+     * Default value is 512.
      */
-    get scene(): T;
+    height?: number;
     /**
-     * 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.
+     * Whether the visibility check should be performed automatically.
+     * Default value is true.
      */
-    set scene(scene: T);
+    autoUpdate?: boolean;
+}
+/**
+ * A base renderer to determine visibility on screen.
+ */
+export declare class CullerRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
+     * 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 camera(): U;
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
     /**
-     * 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.
+     * Whether this renderer is active or not. If not, it won't render anything.
      */
-    set camera(camera: U);
+    enabled: boolean;
     /**
-     * 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).
+     * Needs to check whether there are objects that need to be hidden or shown.
+     * You can bind this to the camera movement, to a certain interval, etc.
      */
-    get renderer(): S | null;
+    needsUpdate: boolean;
     /**
-     * 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.
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
      */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /** 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 autoUpdate: boolean;
+    protected updateInterval: number;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _width;
+    private _height;
+    private _availableColor;
+    private readonly renderTarget;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
     /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
+    dispose(): void;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    updateVisibility: (force?: boolean) => Promise<void>;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
+    private applySettings;
 }
 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";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
 /**
- * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
  */
-export interface World extends Disposable, Updateable {
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
      */
-    meshes: Set<THREE.Mesh>;
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
     /**
-     * The base scene of the world.
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
      */
-    scene: BaseScene;
+    threshold: number;
     /**
-     * The base camera of the world.
+     * Map of color code to THREE.InstancedMesh.
+     * Used to keep track of color-coded meshes.
      */
-    camera: BaseCamera;
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
+     * Flag to indicate if the renderer is currently processing.
+     * Used to prevent concurrent processing.
      */
-    renderer: BaseRenderer | null;
+    isProcessing: boolean;
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private _intervalID;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * A unique identifier for the world.
+     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
+     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
      */
-    uuid: string;
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
+     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
+     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
      */
-    isDisposing: boolean;
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
 }
 import * as THREE from "three";
 import { BaseScene, Configurable, Event } from "../../Types";
@@ -3122,95 +3067,116 @@ export declare class SimpleRenderer extends BaseRenderer {
     private onContextBack;
 }
 import * as THREE from "three";
-import { Components } from "../../Components";
-import { AsyncEvent, Event, World } from "../../Types";
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
 /**
- * Settings to configure the CullerRenderer.
+ * 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 interface CullerRendererSettings {
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
     /**
-     * Interval in milliseconds at which the visibility check should be performed.
-     * Default value is 1000.
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
      */
-    updateInterval?: number;
+    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>;
     /**
-     * Width of the render target used for visibility checks.
-     * Default value is 512.
+     * 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.
      */
-    width?: number;
+    isDisposing: boolean;
     /**
-     * Height of the render target used for visibility checks.
-     * Default value is 512.
+     * Indicates whether the world is currently enabled.
+     * When disabled, the world will not be updated.
      */
-    height?: number;
+    enabled: boolean;
     /**
-     * Whether the visibility check should be performed automatically.
-     * Default value is true.
+     * A unique identifier for the world.
      */
-    autoUpdate?: boolean;
-}
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class CullerRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    uuid: 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.
+     * An optional name for the world.
      */
-    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
+    name?: string;
+    private _scene?;
+    private _camera?;
+    private _renderer;
     /**
-     * Whether this renderer is active or not. If not, it won't render anything.
+     * Getter for the scene. If no scene is initialized, it throws an error.
+     * @returns The current scene.
      */
-    enabled: boolean;
+    get scene(): T;
     /**
-     * Needs to check whether there are objects that need to be hidden or shown.
-     * You can bind this to the camera movement, to a certain interval, etc.
+     * 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.
      */
-    needsUpdate: boolean;
+    set scene(scene: T);
     /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
+     * Getter for the camera. If no camera is initialized, it throws an error.
+     * @returns The current camera.
      */
-    renderDebugFrame: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /** 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 autoUpdate: boolean;
-    protected updateInterval: number;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _width;
-    private _height;
-    private _availableColor;
-    private readonly renderTarget;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    get camera(): U;
     /**
-     * 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.
+     * 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.
      */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-    private applySettings;
+    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;
+}
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
+import { NavigationMode } from "./types";
+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 CameraControls from "camera-controls";
@@ -3275,62 +3241,6 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
     private static getSubsetOfThree;
 }
 import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-/**
- * A renderer to hide/show meshes depending on their visibility from the user's point of view.
- */
-export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
-    /**
-     * Event triggered when the visibility of meshes is updated.
-     * Contains two sets: seen and unseen.
-     */
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
-    }>;
-    /**
-     * Pixels in screen a geometry must occupy to be considered "seen".
-     * Default value is 100.
-     */
-    threshold: number;
-    /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
-     */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    /**
-     * Flag to indicate if the renderer is currently processing.
-     * Used to prevent concurrent processing.
-     */
-    isProcessing: boolean;
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private _intervalID;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
-     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
-     */
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    /**
-     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
-     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
-     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
-     */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
-}
-import * as THREE from "three";
 import { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
 /**
@@ -3429,67 +3339,96 @@ export declare class SimplePlane implements Disposable, Hideable {
     private newHelper;
     private static newPlaneMesh;
 }
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
-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";
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
 /**
- * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
  */
-export declare class IfcStreamingSettings extends IfcFragmentSettings {
+export declare class ProjectionManager {
     /**
-     * Minimum number of geometries to be streamed.
-     * Defaults to 10 geometries.
+     * Event that fires when the {@link CameraProjection} changes.
      */
-    minGeometrySize: number;
+    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
     /**
-     * Minimum amount of assets to be streamed.
-     * Defaults to 1000 assets.
+     * Current projection mode of the camera.
+     * Default is "Perspective".
      */
-    minAssetsSize: number;
-}
-import { IfcFragmentSettings } from "../../IfcLoader/src";
-/**
- * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
- */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    current: CameraProjection;
     /**
-     * Amount of properties to be streamed.
-     * Defaults to 100 properties.
+     * The camera controlled by this ProjectionManager.
+     * It can be either a PerspectiveCamera or an OrthographicCamera.
      */
-    propertiesSize: number;
+    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>;
+    /**
+     * 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;
 }
 /**
- * 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.
+ * The projection system of the camera.
  */
-export interface StreamedGeometries {
-    [id: number]: {
-        /** The bounding box of the geometry as a Float32Array. */
-        boundingBox: Float32Array;
-        /** A boolean indicating whether the geometry has holes. */
-        hasHoles: boolean;
-        /** An optional file path for the geometry data. */
-        geometryFile?: string;
-    };
+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 streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
  */
-export interface StreamedAsset {
-    /** The unique identifier of the asset. */
-    id: number;
-    /** An array of geometries associated with the asset. */
-    geometries: {
-        /** The unique identifier of the geometry. */
-        geometryID: number;
-        /** The transformation matrix of the geometry as a number array. */
-        transformation: number[];
-        /** The color of the geometry as a number array. */
-        color: number[];
-    }[];
+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 * as WEBIFC from "web-ifc";
@@ -3507,6 +3446,11 @@ export declare class CivilReader {
     private getCurves;
 }
 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;
@@ -3516,6 +3460,35 @@ export declare class Units {
     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.
+ */
+export interface StreamedGeometries {
+    [id: number]: {
+        /** The bounding box of the geometry as a Float32Array. */
+        boundingBox: Float32Array;
+        /** A boolean indicating whether the geometry has holes. */
+        hasHoles: boolean;
+        /** An optional file path for the geometry data. */
+        geometryFile?: string;
+    };
+}
+/**
+ * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
+ */
+export interface StreamedAsset {
+    /** The unique identifier of the asset. */
+    id: number;
+    /** An array of geometries associated with the asset. */
+    geometries: {
+        /** The unique identifier of the geometry. */
+        geometryID: number;
+        /** The transformation matrix of the geometry as a number array. */
+        transformation: number[];
+        /** The color of the geometry as a number array. */
+        color: number[];
+    }[];
+}
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
     [modelID: string]: RelationsMap;
@@ -3540,6 +3513,33 @@ export type InverseAttributes = [
     "ContainsElements"
 ];
 export type InverseAttribute = InverseAttributes[number];
+import { IfcFragmentSettings } from "../../IfcLoader/src";
+/**
+ * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
+ */
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
+    /**
+     * Minimum number of geometries to be streamed.
+     * Defaults to 10 geometries.
+     */
+    minGeometrySize: number;
+    /**
+     * Minimum amount of assets to be streamed.
+     * Defaults to 1000 assets.
+     */
+    minAssetsSize: number;
+}
+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 { BufferGeometry } from "three";
 import * as THREE from "three";
 export declare class TransformHelper {