@thatopen/components 2.0.20 → 2.0.22

package/dist/namespace.d.ts

@@ -1,125 +1,4 @@
 declare namespace OBC {
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
-/**
- * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * Return the UUIDs of all disposed components.
-     */
-    get(): Set<string>;
-    /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
-     *
-     * @param recursive - whether to recursively dispose the children of the mesh.
-     */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
-    /**
-     * Disposes a geometry from memory.
-     *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
-     */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}
-import { Component, Disposable, Event } from "../Types";
-/**
- * The entry point of the Components library. It can create, delete and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
- */
-export declare class Components implements Disposable {
-    /**
-     * The version of the @thatopen/components library.
-     */
-    static readonly release = "2.0.20";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<void>;
-    /**
-     * The list of components created in this app.
-     * The keys are UUIDs and the values are instances of the components.
-     */
-    readonly list: Map<string, Component>;
-    /**
-     * If disabled, the animation loop will be stopped.
-     * Default value is false.
-     */
-    enabled: boolean;
-    private _clock;
-    /**
-     * Adds a component to the list of components.
-     * Throws an error if a component with the same UUID already exists.
-     *
-     * @param uuid - The unique identifier of the component.
-     * @param instance - The instance of the component to be added.
-     *
-     * @throws Will throw an error if a component with the same UUID already exists.
-     *
-     * @internal
-     */
-    add(uuid: string, instance: Component): void;
-    /**
-     * Retrieves a component instance by its constructor function.
-     * If the component does not exist in the list, it will be created and added.
-     *
-     * @template U - The type of the component to retrieve.
-     * @param Component - The constructor function of the component to retrieve.
-     *
-     * @returns The instance of the requested component.
-     *
-     * @throws Will throw an error if a component with the same UUID already exists.
-     *
-     * @internal
-     */
-    get<U extends Component>(Component: new (components: Components) => U): U;
-    constructor();
-    /**
-     * Initializes the Components instance.
-     * This method starts the animation loop, sets the enabled flag to true,
-     * and calls the update method.
-     *
-     * @returns {void}
-     */
-    init(): void;
-    /**
-     * Disposes the memory of all the components and tools of this instance of
-     * the library. A memory leak will be created if:
-     *
-     * - An instance of the library ends up out of scope and this function isn't
-     * called. This is especially relevant in Single Page Applications (React,
-     * Angular, Vue, etc).
-     *
-     * - Any of the objects of this instance (meshes, geometries,materials, etc) is
-     * referenced by a reference type (object or array).
-     *
-     * You can learn more about how Three.js handles memory leaks
-     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
-     *
-     */
-    dispose(): void;
-    private update;
-    private static setupBVH;
-}
 import { Component, Disposable, World, Event } from "../Types";
 import { SimpleRaycaster } from "./src";
 import { Components } from "../Components";
@@ -229,55 +108,6 @@ export declare class Worlds extends Component implements Updateable, Disposable
     /** {@link Updateable.update} */
     update(delta?: number): void | Promise<void>;
 }
-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 * as THREE from "three";
 import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
 import { SimplePlane } from "./src";
@@ -405,100 +235,223 @@ export declare class Clipper extends Component implements Createable, Disposable
     private _onStartDragging;
     private _onEndDragging;
 }
-import { Components } from "../Components";
-import { MeshCullerRenderer, CullerRendererSettings } from "./src";
-import { Component, Event, Disposable, World } from "../Types";
+import { Component, Disposable, Event } from "../Types";
 /**
- * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
+ * 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.
  */
-export declare class Cullers extends Component implements Disposable {
+export declare class Components implements Disposable {
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * The version of the @thatopen/components library.
      */
-    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
+    static readonly release = "2.0.22";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<void>;
     /**
-     * An event that is triggered when the Cullers component is disposed.
+     * The list of components created in this app.
+     * The keys are UUIDs and the values are instances of the components.
      */
-    readonly onDisposed: Event<unknown>;
-    private _enabled;
+    readonly list: Map<string, Component>;
     /**
-     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
+     * If disabled, the animation loop will be stopped.
+     * Default value is false.
      */
-    list: Map<string, MeshCullerRenderer>;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(value: boolean);
-    constructor(components: Components);
+    enabled: boolean;
+    private _clock;
     /**
-     * Creates a new MeshCullerRenderer for the given world.
-     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
+     * Adds a component to the list of components.
+     * Throws an error if a component with the same UUID already exists.
      *
-     * @param world - The world for which to create the MeshCullerRenderer.
-     * @param config - Optional configuration settings for the MeshCullerRenderer.
+     * @param uuid - The unique identifier of the component.
+     * @param instance - The instance of the component to be added.
      *
-     * @returns The newly created or existing MeshCullerRenderer for the given world.
+     * @throws Will throw an error if a component with the same UUID already exists.
+     *
+     * @internal
      */
-    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
+    add(uuid: string, instance: Component): void;
     /**
-     * Deletes the MeshCullerRenderer associated with the given world.
-     * If a MeshCullerRenderer exists for the given world, it will be disposed and removed from the list.
+     * Retrieves a component instance by its constructor function.
+     * If the component does not exist in the list, it will be created and added.
      *
-     * @param world - The world for which to delete the MeshCullerRenderer.
+     * @template U - The type of the component to retrieve.
+     * @param Component - The constructor function of the component to retrieve.
+     *
+     * @returns The instance of the requested component.
+     *
+     * @throws Will throw an error if a component with the same UUID already exists.
+     *
+     * @internal
+     */
+    get<U extends Component>(Component: new (components: Components) => U): U;
+    constructor();
+    /**
+     * Initializes the Components instance.
+     * This method starts the animation loop, sets the enabled flag to true,
+     * and calls the update method.
      *
      * @returns {void}
      */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
+    init(): void;
+    /**
+     * Disposes the memory of all the components and tools of this instance of
+     * the library. A memory leak will be created if:
+     *
+     * - An instance of the library ends up out of scope and this function isn't
+     * called. This is especially relevant in Single Page Applications (React,
+     * Angular, Vue, etc).
+     *
+     * - Any of the objects of this instance (meshes, geometries,materials, etc) is
+     * referenced by a reference type (object or array).
+     *
+     * You can learn more about how Three.js handles memory leaks
+     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+     *
+     */
     dispose(): void;
+    private update;
+    private static setupBVH;
 }
-import { 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;
+    constructor(components: Components);
     /**
-     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
+     * 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.
      */
-    list: Map<string, MiniMap>;
+    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 { Components } from "../Components";
+import { MeshCullerRenderer, CullerRendererSettings } from "./src";
+import { Component, Event, Disposable, World } from "../Types";
+/**
+ * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
+ */
+export declare class Cullers 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: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
+    /**
+     * An event that is triggered when the Cullers component is disposed.
+     */
+    readonly onDisposed: Event<unknown>;
+    private _enabled;
+    /**
+     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
+     */
+    list: Map<string, MeshCullerRenderer>;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(value: boolean);
     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 MeshCullerRenderer for the given world.
+     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
      *
-     * @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.
+     * @param world - The world for which to create the MeshCullerRenderer.
+     * @param config - Optional configuration settings for the MeshCullerRenderer.
+     *
+     * @returns The newly created or existing MeshCullerRenderer for the given world.
      */
-    create(world: World): MiniMap;
+    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
     /**
-     * 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 MeshCullerRenderer associated with the given world.
+     * If a MeshCullerRenderer exists for the given world, it will be disposed and removed from the list.
+     *
+     * @param world - The world for which to delete the MeshCullerRenderer.
      *
-     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
      * @returns {void}
      */
-    delete(id: string): void;
+    delete(world: World): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
+}
+import * as THREE from "three";
+import { Components } from "../Components";
+import { Component } from "../Types";
+/**
+ * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ */
+export declare class Disposer extends Component {
+    private _disposedComponents;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
+    constructor(components: Components);
+    /**
+     * Return the UUIDs of all disposed components.
+     */
+    get(): Set<string>;
+    /**
+     * Removes a mesh, its geometry and its materials from memory. If you are
+     * using any of these in other parts of the application, make sure that you
+     * remove them from the mesh before disposing it.
+     *
+     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
+     * to remove.
+     *
+     * @param materials - whether to dispose the materials of the mesh.
+     *
+     * @param recursive - whether to recursively dispose the children of the mesh.
+     */
+    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
+    /**
+     * Disposes a geometry from memory.
+     *
+     * @param geometry - the
+     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+     * to remove.
+     */
+    disposeGeometry(geometry: THREE.BufferGeometry): void;
+    private disposeGeometryAndMaterials;
+    private disposeChildren;
+    private static disposeMaterial;
 }
 import * as THREE from "three";
 import { Components } from "../Components";
@@ -565,101 +518,278 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
     private setOrthoPerspCameraAspect;
 }
 import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Components, Disposable, Event } from "../../core";
+export declare function obbFromPoints(vertices: ArrayLike<number>): {
+    center: THREE.Vector3;
+    halfSizes: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    transformation: THREE.Matrix4;
+};
+import { MiniMap } from "./src";
+import { Component, Updateable, World, Event, Disposable } from "../Types";
+import { Components } from "../Components";
 /**
- * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but it's fast, and should suffice for general use cases such as camera zooming or general boundary determination. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/BoundingBoxer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/BoundingBoxer).
+ * 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 BoundingBoxer extends Component implements Disposable {
-    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
-    /** {@link Component.enabled} */
-    enabled: boolean;
+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: "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>;
-    private _absoluteMin;
-    private _absoluteMax;
-    private _meshes;
-    constructor(components: Components);
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * A static method to calculate the dimensions of a given bounding box.
-     *
-     * @param bbox - The bounding box to calculate the dimensions for.
-     * @returns An object containing the width, height, depth, and center of the bounding box.
+     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
      */
-    static getDimensions(bbox: THREE.Box3): {
-        width: number;
-        height: number;
-        depth: number;
-        center: THREE.Vector3;
-    };
+    list: Map<string, MiniMap>;
+    constructor(components: Components);
     /**
-     * A static method to create a new bounding box boundary.
-     *
-     * @param positive - A boolean indicating whether to create a boundary for positive or negative values.
-     * @returns A new THREE.Vector3 representing the boundary.
-     *
-     * @remarks
-     * This method is used to create a new boundary for calculating bounding boxes.
-     * It sets the x, y, and z components of the returned vector to positive or negative infinity,
-     * depending on the value of the 'positive' parameter.
-     *
-     * @example
-     * '''typescript
-     * const positiveBound = BoundingBoxer.newBound(true);
-     * console.log(positiveBound); // Output: Vector3 { x: Infinity, y: Infinity, z: Infinity }
+     * 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.
      *
-     * const negativeBound = BoundingBoxer.newBound(false);
-     * console.log(negativeBound); // Output: Vector3 { x: -Infinity, y: -Infinity, z: -Infinity }
-     * '''
+     * @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.
      */
-    static newBound(positive: boolean): THREE.Vector3;
+    create(world: World): MiniMap;
     /**
-     * A static method to calculate the bounding box of a set of points.
-     *
-     * @param points - An array of THREE.Vector3 representing the points.
-     * @param min - An optional THREE.Vector3 representing the minimum bounds. If not provided, it will be calculated.
-     * @param max - An optional THREE.Vector3 representing the maximum bounds. If not provided, it will be calculated.
-     * @returns A THREE.Box3 representing the bounding box of the given points.
-     *
-     * @remarks
-     * This method calculates the bounding box of a set of points by iterating through each point and updating the minimum and maximum bounds accordingly.
-     * If the 'min' or 'max' parameters are provided, they will be used as the initial bounds. Otherwise, the initial bounds will be set to positive and negative infinity.
-     *
-     * @example
-     * '''typescript
-     * const points = [
-     *   new THREE.Vector3(1, 2, 3),
-     *   new THREE.Vector3(4, 5, 6),
-     *   new THREE.Vector3(7, 8, 9),
-     * ];
+     * 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.
      *
-     * const bbox = BoundingBoxer.getBounds(points);
-     * console.log(bbox); // Output: Box3 { min: Vector3 { x: 1, y: 2, z: 3 }, max: Vector3 { x: 7, y: 8, z: 9 } }
-     * '''
+     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
+     * @returns {void}
      */
-    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
+    delete(id: string): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /**
-     * Returns the bounding box of the calculated fragments.
-     *
-     * @returns A new THREE.Box3 instance representing the bounding box.
-     *
-     * @remarks
-     * This method clones the internal minimum and maximum vectors and returns a new THREE.Box3 instance.
-     * The returned box represents the bounding box of the calculated fragments.
-     *
-     * @example
-     * '''typescript
-     * const boundingBox = boundingBoxer.get();
-     * console.log(boundingBox); // Output: Box3 { min: Vector3 { x: -10, y: -10, z: -10 }, max: Vector3 { x: 10, y: 10, z: 10 } }
-     * '''
-     */
-    get(): THREE.Box3;
-    /**
-     * Calculates and returns a sphere that encompasses the entire bounding box.
-     *
+    /** {@link Updateable.update} */
+    update(): void;
+}
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
+export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
+import * as THREE from "three";
+import { Component, Components, Disposable, Event, World } from "../core";
+/**
+ * Configuration interface for the VertexPicker component.
+ */
+export interface VertexPickerConfig {
+    /**
+     * If true, only vertices will be picked, not the closest point on the face.
+     */
+    showOnlyVertex: boolean;
+    /**
+     * The maximum distance for snapping to a vertex.
+     */
+    snapDistance: number;
+    /**
+     * The HTML element to use for previewing the picked vertex.
+     */
+    previewElement: HTMLElement;
+}
+/**
+ * A class that provides functionality for picking vertices in a 3D scene.
+ */
+export declare class VertexPicker extends Component implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
+     */
+    readonly onVertexFound: Event<THREE.Vector3>;
+    /**
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
+     */
+    readonly onVertexLost: Event<THREE.Vector3>;
+    /**
+     * A reference to the Components instance associated with this VertexPicker.
+     */
+    components: Components;
+    /**
+     * A reference to the working plane used for vertex picking.
+     * This plane is used to determine which vertices are considered valid for picking.
+     * If this value is null, all vertices are considered valid.
+     */
+    workingPlane: THREE.Plane | null;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
+    /**
+     * Sets the enabled state of the VertexPicker.
+     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
+     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
+     *
+     * @param value - The new enabled state.
+     */
+    set enabled(value: boolean);
+    /**
+     * Gets the current enabled state of the VertexPicker.
+     *
+     * @returns The current enabled state.
+     */
+    get enabled(): boolean;
+    /**
+     * Sets the configuration for the VertexPicker component.
+     *
+     * @param value - A Partial object containing the configuration properties to update.
+     * The properties not provided in the value object will retain their current values.
+     *
+     * @example
+     * '''typescript
+     * vertexPicker.config = {
+     *   snapDistance: 0.5,
+     *   showOnlyVertex: true,
+     * };
+     * '''
+     */
+    set config(value: Partial<VertexPickerConfig>);
+    /**
+     * Gets the current configuration for the VertexPicker component.
+     *
+     * @returns A copy of the current VertexPickerConfig object.
+     *
+     * @example
+     * '''typescript
+     * const currentConfig = vertexPicker.config;
+     * console.log(currentConfig.snapDistance); // Output: 0.25
+     * '''
+     */
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
+     *
+     * @param world - The World instance to use for raycasting.
+     *
+     * @returns The current picked point, or null if no point is picked.
+     *
+     * @remarks
+     * This method checks if the VertexPicker is enabled. If not, it returns the current picked point.
+     * If enabled, it performs raycasting to find the closest intersecting object.
+     * It then determines the closest vertex or point on the face, based on the configuration settings.
+     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
+     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
+     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
+     */
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Components, Disposable, Event } from "../../core";
+/**
+ * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but it's fast, and should suffice for general use cases such as camera zooming or general boundary determination. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/BoundingBoxer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/BoundingBoxer).
+ */
+export declare class BoundingBoxer extends Component implements Disposable {
+    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    private _absoluteMin;
+    private _absoluteMax;
+    private _meshes;
+    constructor(components: Components);
+    /**
+     * A static method to calculate the dimensions of a given bounding box.
+     *
+     * @param bbox - The bounding box to calculate the dimensions for.
+     * @returns An object containing the width, height, depth, and center of the bounding box.
+     */
+    static getDimensions(bbox: THREE.Box3): {
+        width: number;
+        height: number;
+        depth: number;
+        center: THREE.Vector3;
+    };
+    /**
+     * A static method to create a new bounding box boundary.
+     *
+     * @param positive - A boolean indicating whether to create a boundary for positive or negative values.
+     * @returns A new THREE.Vector3 representing the boundary.
+     *
+     * @remarks
+     * This method is used to create a new boundary for calculating bounding boxes.
+     * It sets the x, y, and z components of the returned vector to positive or negative infinity,
+     * depending on the value of the 'positive' parameter.
+     *
+     * @example
+     * '''typescript
+     * const positiveBound = BoundingBoxer.newBound(true);
+     * console.log(positiveBound); // Output: Vector3 { x: Infinity, y: Infinity, z: Infinity }
+     *
+     * const negativeBound = BoundingBoxer.newBound(false);
+     * console.log(negativeBound); // Output: Vector3 { x: -Infinity, y: -Infinity, z: -Infinity }
+     * '''
+     */
+    static newBound(positive: boolean): THREE.Vector3;
+    /**
+     * A static method to calculate the bounding box of a set of points.
+     *
+     * @param points - An array of THREE.Vector3 representing the points.
+     * @param min - An optional THREE.Vector3 representing the minimum bounds. If not provided, it will be calculated.
+     * @param max - An optional THREE.Vector3 representing the maximum bounds. If not provided, it will be calculated.
+     * @returns A THREE.Box3 representing the bounding box of the given points.
+     *
+     * @remarks
+     * This method calculates the bounding box of a set of points by iterating through each point and updating the minimum and maximum bounds accordingly.
+     * If the 'min' or 'max' parameters are provided, they will be used as the initial bounds. Otherwise, the initial bounds will be set to positive and negative infinity.
+     *
+     * @example
+     * '''typescript
+     * const points = [
+     *   new THREE.Vector3(1, 2, 3),
+     *   new THREE.Vector3(4, 5, 6),
+     *   new THREE.Vector3(7, 8, 9),
+     * ];
+     *
+     * const bbox = BoundingBoxer.getBounds(points);
+     * console.log(bbox); // Output: Box3 { min: Vector3 { x: 1, y: 2, z: 3 }, max: Vector3 { x: 7, y: 8, z: 9 } }
+     * '''
+     */
+    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Returns the bounding box of the calculated fragments.
+     *
+     * @returns A new THREE.Box3 instance representing the bounding box.
+     *
+     * @remarks
+     * This method clones the internal minimum and maximum vectors and returns a new THREE.Box3 instance.
+     * The returned box represents the bounding box of the calculated fragments.
+     *
+     * @example
+     * '''typescript
+     * const boundingBox = boundingBoxer.get();
+     * console.log(boundingBox); // Output: Box3 { min: Vector3 { x: -10, y: -10, z: -10 }, max: Vector3 { x: 10, y: 10, z: 10 } }
+     * '''
+     */
+    get(): THREE.Box3;
+    /**
+     * Calculates and returns a sphere that encompasses the entire bounding box.
+     *
      * @returns A new THREE.Sphere instance representing the calculated sphere.
      *
      * @remarks
@@ -750,168 +880,118 @@ export declare class BoundingBoxer extends Component implements Disposable {
     private static getFragmentBounds;
 }
 import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Disposable, Component, Event, Components } from "../../core";
+import { Component, 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 to their respective express IDs.
+ * Represents an edge measurement result.
  */
-export interface Classification {
+export interface MeasureEdge {
     /**
-     * A system within the classification.
-     * The key is the system name, and the value is an object representing the classes within the system.
+     * The distance between the two points of the edge.
      */
-    [system: string]: {
-        /**
-         * A class within the system.
-         * The key is the class name, and the value is a map of fragment IDs to their respective express IDs.
-         */
-        [className: string]: FRAGS.FragmentIdMap;
-    };
+    distance: number;
+    /**
+     * The two points that define the edge.
+     */
+    points: THREE.Vector3[];
 }
 /**
- * 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).
+ * 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 Classifier extends Component implements Disposable {
+export declare class MeasurementUtils extends Component {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    static uuid: string;
     /** {@link Component.enabled} */
     enabled: boolean;
+    constructor(components: Components);
     /**
-     * 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<unknown>;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * 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.
-     */
-    remove(guid: string): 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.
-     *
-     * @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.
-     */
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
-    /**
-     * 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.
+     * Utility method to calculate the distance from a point to a line segment.
      *
+     * @param point - The point from which to calculate the distance.
+     * @param lineStart - The start point of the line segment.
+     * @param lineEnd - The end point of the line segment.
+     * @param clamp - If true, the distance will be clamped to the line segment's length.
+     * @returns The distance from the point to the line segment.
      */
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
     /**
-     * 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.
+     * 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.
      *
-     * @throws Will throw an error if the fragment ID is not found.
+     * @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.
      */
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<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.
+     * 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 fragment ID is not found.
+     * @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.
      */
-    byEntity(group: FRAGS.FragmentsGroup): void;
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
     /**
-     * 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.
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
      *
-     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
      */
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    round(vector: THREE.Vector3): void;
+    private getFaceData;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
+/**
+ * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
+ */
+export declare class Hider extends Component {
     /**
-     * Classifies fragments based on their spatial structure in the IFC model.
-     *
-     * @param model - 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 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.
-     *
-     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
     /**
-     * Sets the color of the specified fragments.
-     *
-     * @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.
+     * Sets the visibility of fragments within the 3D scene.
+     * If no 'items' parameter is provided, all fragments will be set to the specified visibility.
+     * If 'items' is provided, only the specified fragments will be affected.
      *
-     * @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 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.
      *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
+     * @returns {void}
      */
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
     /**
-     * Resets the color of the specified fragments to their original color.
-     *
-     * @param items - A map of fragment IDs to their respective express IDs.
+     * 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.
      *
-     * @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 items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
+     * If not provided, all fragments will be isolated.
      *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
+     * @returns {void}
      */
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
 }
 import { Component, Disposable, Event, Components } from "../../core";
 /**
@@ -963,44 +1043,6 @@ export declare class Exploder extends Component implements Disposable {
      */
     set(active: boolean): void;
 }
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
-/**
- * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
- */
-export declare class Hider extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Sets the visibility of fragments within the 3D scene.
-     * If no 'items' parameter is provided, all fragments will be set to the specified visibility.
-     * If 'items' is provided, only the specified fragments will be affected.
-     *
-     * @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 * as WEBIFC from "web-ifc";
 import * as FRAGS from "@thatopen/fragments";
 import { IfcFragmentSettings } from "./src";
@@ -1416,164 +1458,34 @@ export declare class IfcJsonExporter extends Component {
      */
     export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
-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";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
-}
-import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
+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";
 /**
- * Configuration interface for the VertexPicker component.
+ * 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 interface VertexPickerConfig {
+export declare class IfcRelationsIndexer extends Component implements Disposable {
     /**
-     * If true, only vertices will be picked, not the closest point on the face.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    showOnlyVertex: boolean;
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * The maximum distance for snapping to a vertex.
+     * 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.
      */
-    snapDistance: number;
-    /**
-     * The HTML element to use for previewing the picked vertex.
-     */
-    previewElement: HTMLElement;
-}
-/**
- * A class that provides functionality for picking vertices in a 3D scene.
- */
-export declare class VertexPicker extends Component implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a vertex is found.
-     * The event passes a THREE.Vector3 representing the position of the found vertex.
-     */
-    readonly onVertexFound: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
-     */
-    readonly onVertexLost: Event<THREE.Vector3>;
-    /**
-     * A reference to the Components instance associated with this VertexPicker.
-     */
-    components: Components;
-    /**
-     * A reference to the working plane used for vertex picking.
-     * This plane is used to determine which vertices are considered valid for picking.
-     * If this value is null, all vertices are considered valid.
-     */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
-    /**
-     * Sets the enabled state of the VertexPicker.
-     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
-     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
-     *
-     * @param value - The new enabled state.
-     */
-    set enabled(value: boolean);
-    /**
-     * Gets the current enabled state of the VertexPicker.
-     *
-     * @returns The current enabled state.
-     */
-    get enabled(): boolean;
-    /**
-     * Sets the configuration for the VertexPicker component.
-     *
-     * @param value - A Partial object containing the configuration properties to update.
-     * The properties not provided in the value object will retain their current values.
-     *
-     * @example
-     * '''typescript
-     * vertexPicker.config = {
-     *   snapDistance: 0.5,
-     *   showOnlyVertex: true,
-     * };
-     * '''
-     */
-    set config(value: Partial<VertexPickerConfig>);
-    /**
-     * Gets the current configuration for the VertexPicker component.
-     *
-     * @returns A copy of the current VertexPickerConfig object.
-     *
-     * @example
-     * '''typescript
-     * const currentConfig = vertexPicker.config;
-     * console.log(currentConfig.snapDistance); // Output: 0.25
-     * '''
-     */
-    get config(): Partial<VertexPickerConfig>;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Performs the vertex picking operation based on the current state of the VertexPicker.
-     *
-     * @param world - The World instance to use for raycasting.
-     *
-     * @returns The current picked point, or null if no point is picked.
-     *
-     * @remarks
-     * This method checks if the VertexPicker is enabled. If not, it returns the current picked point.
-     * If enabled, it performs raycasting to find the closest intersecting object.
-     * It then determines the closest vertex or point on the face, based on the configuration settings.
-     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
-     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
-     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
-     */
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
-}
-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";
-/**
- * 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 IfcRelationsIndexer extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Event triggered when relations for a model have been indexed.
-     * This event provides the model's UUID and the relations map generated for that model.
-     *
-     * @property {string} modelID - The UUID of the model for which relations have been indexed.
-     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
-     * The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
-     */
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
+    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.
@@ -1687,125 +1599,289 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     /** {@link Disposable.dispose} */
     dispose(): 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>;
-}
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Disposable, Component, Event, Components } from "../../core";
 /**
- * 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.
+ * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs to their respective express IDs.
  */
-export interface AttributeListener {
-    [modelID: string]: {
-        [expressID: number]: {
-            [attributeName: string]: Event<String | Boolean | Number>;
-        };
+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 a map of fragment IDs to their respective express IDs.
+         */
+        [className: string]: FRAGS.FragmentIdMap;
     };
 }
 /**
- * Component to manage and edit properties and Psets in IFC files.
+ * 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 IfcPropertiesManager extends Component implements Disposable {
+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: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Event triggered when a file is requested for export.
-     */
-    readonly onRequestFile: Event<unknown>;
-    /**
-     * ArrayBuffer containing the IFC data to be exported.
-     */
-    ifcToExport: ArrayBuffer | null;
-    /**
-     * Event triggered when an element is added to a Pset.
-     */
-    readonly onElementToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        elementID: number;
-    }>;
-    /**
-     * Event triggered when a property is added to a Pset.
-     */
-    readonly onPropToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        propID: number;
-    }>;
-    /**
-     * Event triggered when a Pset is removed.
-     */
-    readonly onPsetRemoved: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-    }>;
-    /**
-     * Event triggered when data in the model changes.
-     */
-    readonly onDataChanged: Event<{
-        model: FragmentsGroup;
-        expressID: number;
-    }>;
-    /**
-     * Configuration for the WebAssembly module.
-     */
-    wasm: {
-        path: string;
-        absolute: boolean;
-    };
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
     /** {@link Component.enabled} */
     enabled: boolean;
     /**
-     * Map of attribute listeners.
-     */
-    attributeListeners: AttributeListener;
-    /**
-     * The currently selected model.
-     */
-    selectedModel?: FragmentsGroup;
-    /**
-     * Map of changed entities in the model.
+     * A map representing the classification systems.
+     * The key is the system name, and the value is an object representing the classes within the system.
      */
-    changeMap: ChangeMap;
+    list: Classification;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     constructor(components: Components);
+    private onFragmentsDisposed;
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
-     * Static method to retrieve the IFC schema from a given model.
+     * 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 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 guid - The unique identifier of the fragment to be removed.
      */
-    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
+    remove(guid: string): void;
     /**
-     * Method to set properties data in the model.
+     * Finds and returns fragments based on the provided filter criteria.
+     * If no filter is provided, it returns all fragments.
      *
-     * @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.
+     * @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.
+     */
+    find(filter?: {
+        [name: string]: string[];
+    }): FRAGS.FragmentIdMap;
+    /**
+     * 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.
+     *
+     */
+    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    /**
+     * 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.
+     */
+    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    /**
+     * 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.
+     *
+     * @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
+     * 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.
+     *
+     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
+     */
+    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    /**
+     * Classifies fragments based on their spatial structure in the IFC model.
+     *
+     * @param model - 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 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.
+     *
+     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
+     */
+    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
+    /**
+     * Sets the color of the specified fragments.
+     *
+     * @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.
+     *
+     * @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 iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and resets their color using the 'resetColor' method of the FragmentsGroup class.
+     *
+     * @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): 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>;
+        };
+    };
+}
+/**
+ * Component to manage and edit properties and Psets in IFC files.
+ */
+export declare class IfcPropertiesManager extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * Event triggered when a file is requested for export.
+     */
+    readonly onRequestFile: Event<unknown>;
+    /**
+     * ArrayBuffer containing the IFC data to be exported.
+     */
+    ifcToExport: ArrayBuffer | null;
+    /**
+     * Event triggered when an element is added to a Pset.
+     */
+    readonly onElementToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        elementID: number;
+    }>;
+    /**
+     * Event triggered when a property is added to a Pset.
+     */
+    readonly onPropToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        propID: number;
+    }>;
+    /**
+     * Event triggered when a Pset is removed.
+     */
+    readonly onPsetRemoved: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+    }>;
+    /**
+     * Event triggered when data in the model changes.
+     */
+    readonly onDataChanged: Event<{
+        model: FragmentsGroup;
+        expressID: number;
+    }>;
+    /**
+     * Configuration for the WebAssembly module.
+     */
+    wasm: {
+        path: string;
+        absolute: boolean;
+    };
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * Map of attribute listeners.
+     */
+    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;
+    /**
+     * Static method to retrieve the IFC schema from a given model.
+     *
+     * @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.
+     */
+    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
+    /**
+     * 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 {Promise<void>} A promise that resolves when all the properties have been set.
      *
@@ -1943,86 +2019,54 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
     private registerChange;
     private newSingleProperty;
 }
-import * as THREE from "three";
-import { Component, Components } from "../../core";
-/**
- * Represents an edge measurement result.
- */
-export interface MeasureEdge {
-    /**
-     * The distance between the two points of the edge.
-     */
-    distance: number;
-    /**
-     * The two points that define the edge.
-     */
-    points: THREE.Vector3[];
-}
-/**
- * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
- */
-export declare class MeasurementUtils extends Component {
+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;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Generate the geometry for categories that are not included by default,
+     * like IFCSPACE.
      */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Utility method to calculate the distance from a point to a line segment.
-     *
-     * @param point - The point from which to calculate the distance.
-     * @param lineStart - The start point of the line segment.
-     * @param lineEnd - The end point of the line segment.
-     * @param clamp - If true, the distance will be clamped to the line segment's length.
-     * @returns The distance from the point to the line segment.
-     */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    /**
-     * Method to get the face of a mesh that contains a given triangle index.
-     * It also returns the edges of the found face and their indices.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param triangleIndex - The index of the triangle within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
-     */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
+    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;
     /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
+     * 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.
      */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
+    autoSetWasm: boolean;
     /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
+     * 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 vector - The vector to round.
-     * @returns The vector with rounded components.
+     * @param url - The URL of the file to locate.
+     * @returns The absolute path of the file.
      */
-    round(vector: THREE.Vector3): void;
-    private getFaceData;
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
 }
-/**
- * A Set of unique numbers representing different types of IFC geometries.
- */
-export declare const GeometryTypes: Set<number>;
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
 /**
@@ -2112,67 +2156,12 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     resize(size?: THREE.Vector2): void;
     private updatePlanes;
 }
-import { InverseAttribute } from "./types";
-export declare const relToAttributesMap: Map<number, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;
-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 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;
-}
-import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}
+/**
+ * A map 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;
+};
 /**
  * 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.
  *
@@ -2184,12 +2173,14 @@ export declare class IfcCategories {
 export declare const IfcElements: {
     [key: number]: string;
 };
-/**
- * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
- */
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
+}
 import * as FRAGS from "@thatopen/fragments";
 export declare class IfcPropertiesUtils {
     static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
@@ -2216,60 +2207,26 @@ export declare class IfcPropertiesUtils {
     static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
 }
 /**
- * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
+ * A Set of unique numbers representing different types of IFC geometries.
  */
-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;
-}
+export declare const GeometryTypes: Set<number>;
+import { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<number, {
+    forRelating: InverseAttribute;
+    forRelated: InverseAttribute;
+}>;
+import { Base } from "./base";
 /**
- * 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.
+ * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
  */
-export declare class 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;
+export declare abstract class Component extends Base {
     /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
+     * Whether this component is active or not. The behaviour can vary depending
+     * on the type of component. E.g. a disabled dimension tool will stop creating
+     * dimensions, while a disabled camera will stop moving. A disabled component
+     * will not be updated automatically each frame.
      */
-    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;
+    abstract enabled: boolean;
 }
 import * as THREE from "three";
 import CameraControls from "camera-controls";
@@ -2379,33 +2336,76 @@ export interface CameraControllable {
      */
     controls: CameraControls;
 }
-import { Base } from "./base";
 /**
- * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the 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.
+ * 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 Component extends Base {
+export declare class Event<T> {
     /**
-     * Whether this component is active or not. The behaviour can vary depending
-     * on the type of component. E.g. a disabled dimension tool will stop creating
-     * dimensions, while a disabled camera will stop moving. A disabled component
-     * will not be updated automatically each frame.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    abstract enabled: boolean;
-}
-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;
+    add(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /**
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
+     */
+    remove(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => void;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
+}
+/**
+ * Simple event handler by [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 { 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}. */
@@ -2582,79 +2582,83 @@ export interface World extends Disposable, Updateable {
     isDisposing: boolean;
 }
 import * as THREE from "three";
-import { Disposable, Event } from "../../Types";
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } 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.
+ * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
+ *
+ * @template T - The type of the scene. Default is BaseScene.
+ * @template U - The type of the camera. Default is BaseCamera.
+ * @template S - The type of the renderer. Default is BaseRenderer.
  */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
+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>;
-    constructor(dom: HTMLCanvasElement);
     /**
-     * The real position of the mouse of the Three.js canvas.
+     * 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.
      */
-    get position(): THREE.Vector2;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private setupEvents;
-}
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
-/**
- * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
- */
-export declare class SimpleRaycaster implements Disposable {
-    /** {@link Component.enabled} */
     enabled: boolean;
-    /** The components instance to which this Raycaster belongs. */
-    components: Components;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The position of the mouse in the screen. */
-    readonly mouse: Mouse;
     /**
-     * A reference to the Three.js Raycaster instance.
-     * This is used for raycasting operations.
+     * A unique identifier for the world.
      */
-    readonly three: THREE.Raycaster;
+    uuid: string;
     /**
-     * A reference to the world instance to which this Raycaster belongs.
-     * This is used to access the camera and meshes.
+     * An optional name for the world.
      */
-    world: World;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    name?: string;
+    private _scene?;
+    private _camera?;
+    private _renderer;
     /**
-     * Throws a ray from the camera to the mouse or touch event point and returns
-     * the first item found. This also takes into account the clipping planes
-     * used by the renderer.
-     *
-     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
-     * to query. If not provided, it will query all the meshes stored in
-     * {@link Components.meshes}.
+     * Getter for the scene. If no scene is initialized, it throws an error.
+     * @returns The current scene.
      */
-    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    get scene(): T;
     /**
-     * Casts a ray from a given origin in a given direction and returns the first item found.
-     * This method also takes into account the clipping planes used by the renderer.
-     *
-     * @param origin - The origin of the ray.
-     * @param direction - The direction of the ray.
-     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
-     * @returns The first intersection found or 'null' if no intersection was found.
+     * 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.
      */
-    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
-    private intersect;
-    private filterClippingPlanes;
+    set scene(scene: T);
+    /**
+     * Getter for the camera. If no camera is initialized, it throws an error.
+     * @returns The current camera.
+     */
+    get camera(): U;
+    /**
+     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
+     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
+     * @param camera - The new camera to be set.
+     */
+    set camera(camera: U);
+    /**
+     * Getter for the renderer.
+     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
+     */
+    get renderer(): S | null;
+    /**
+     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
+     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
+     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
+     * @param renderer - The new renderer to be set or null to remove the current renderer.
+     */
+    set renderer(renderer: S | null);
+    /** {@link Updateable.update} */
+    update(delta?: number): void;
+    /** {@link Disposable.dispose} */
+    dispose(disposeResources?: boolean): void;
 }
 import * as THREE from "three";
 import { BaseScene, Configurable, Event } from "../../Types";
@@ -2750,142 +2754,86 @@ export declare class SimpleRenderer extends BaseRenderer {
     private onContextBack;
 }
 import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+import { Hideable, Event, World, Disposable } from "../../Types";
+import { Components } from "../../Components";
 /**
- * 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.
+ * Configuration interface for the {@link SimpleGrid} class.
  */
-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;
+export interface GridConfig {
     /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
+     * The color of the grid lines.
      */
-    enabled: boolean;
+    color: THREE.Color;
     /**
-     * A unique identifier for the world.
+     * The size of the primary grid lines.
      */
-    uuid: string;
+    size1: number;
     /**
-     * An optional name for the world.
+     * The size of the secondary grid lines.
      */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
+    size2: number;
     /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
+     * The distance at which the grid lines start to fade away.
      */
-    get scene(): T;
+    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;
     /**
-     * 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 grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    set scene(scene: T);
+    get fade(): boolean;
     /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    get camera(): U;
-    /**
-     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
-     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
-     * @param camera - The new camera to be set.
-     */
-    set camera(camera: U);
-    /**
-     * Getter for the renderer.
-     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
-     */
-    get renderer(): S | null;
-    /**
-     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
-     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
-     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
-     * @param renderer - The new renderer to be set or null to remove the current renderer.
-     */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
+    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(disposeResources?: boolean): void;
+    dispose(): void;
+    private setupEvents;
+    private updateZoom;
 }
 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;
-}
+import { Disposable, Event } from "../../Types";
 /**
- * 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).
+ * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
  */
-export declare class SimpleGrid implements Hideable, Disposable {
+export declare class Mouse implements Disposable {
+    dom: HTMLCanvasElement;
+    private _event?;
+    private _position;
     /** {@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;
+    constructor(dom: HTMLCanvasElement);
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * The real position of the mouse of the Three.js canvas.
      */
-    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);
+    get position(): THREE.Vector2;
     /** {@link Disposable.dispose} */
     dispose(): void;
+    private getPositionY;
+    private getPositionX;
+    private updateMouseInfo;
     private setupEvents;
-    private updateZoom;
 }
 import * as THREE from "three";
 import { Components } from "../../Components";
@@ -3097,6 +3045,113 @@ export declare class MeshCullerRenderer extends CullerRenderer implements Dispos
     private getAvailableMaterial;
 }
 export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
+import { 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 to navigate floorplans in 2D, like many BIM tools.
+ */
+export declare class PlanMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Plan";
+    private mouseAction1?;
+    private mouseAction2?;
+    private mouseInitialized;
+    private readonly defaultAzimuthSpeed;
+    private readonly defaultPolarSpeed;
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+}
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
+    /**
+     * Event that fires when the {@link CameraProjection} changes.
+     */
+    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+    /**
+     * Current projection mode of the camera.
+     * Default is "Perspective".
+     */
+    current: CameraProjection;
+    /**
+     * The camera controlled by this ProjectionManager.
+     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     */
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    private _component;
+    private _previousDistance;
+    constructor(camera: OrthoPerspectiveCamera);
+    /**
+     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     *
+     * @param projection - the new projection to set. If it is the current projection,
+     * it will have no effect.
+     */
+    set(projection: CameraProjection): Promise<void>;
+    /**
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
+     */
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getPerspectiveDims;
+    private setupOrthoCamera;
+    private getDistance;
+    private setPerspectiveCamera;
+}
+/**
+ * The projection system of the camera.
+ */
+export type CameraProjection = "Perspective" | "Orthographic";
+/**
+ * The extensible list of supported navigation modes.
+ */
+export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
+/**
+ * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ */
+export interface NavigationMode {
+    /** The unique ID of this navigation mode. */
+    id: NavModeID;
+    /**
+     * Enable or disable this navigation mode.
+     * When a new navigation mode is enabled, the previous navigation mode
+     * must be disabled.
+     *
+     * @param active - whether to enable or disable this mode.
+     * @param options - any additional data required to enable or disable it.
+     * */
+    set: (active: boolean, options?: any) => void;
+    /** Whether this navigation mode is active or not. */
+    enabled: boolean;
+}
 import * as THREE from "three";
 import { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
@@ -3194,32 +3249,57 @@ export declare class SimplePlane implements Disposable, Hideable {
     private newHelper;
     private static newPlaneMesh;
 }
-import { IfcFragmentSettings } from "../../IfcLoader/src";
+import * as THREE from "three";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+import { Mouse } from "./mouse";
 /**
- * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
  */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+export declare class SimpleRaycaster implements Disposable {
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /** The components instance to which this Raycaster belongs. */
+    components: Components;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** The position of the mouse in the screen. */
+    readonly mouse: Mouse;
     /**
-     * Amount of properties to be streamed.
-     * Defaults to 100 properties.
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
      */
-    propertiesSize: number;
-}
-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;
+    readonly three: THREE.Raycaster;
+    /**
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
+     */
+    world: World;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Throws a ray from the camera to the mouse or touch event point and returns
+     * the first item found. This also takes into account the clipping planes
+     * used by the renderer.
+     *
+     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
+     * to query. If not provided, it will query all the meshes stored in
+     * {@link Components.meshes}.
+     */
+    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    /**
+     * Casts a ray from a given origin in a given direction and returns the first item found.
+     * This method also takes into account the clipping planes used by the renderer.
+     *
+     * @param origin - The origin of the ray.
+     * @param direction - The direction of the ray.
+     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
+     * @returns The first intersection found or 'null' if no intersection was found.
+     */
+    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
+    private intersect;
+    private filterClippingPlanes;
 }
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
@@ -3237,102 +3317,6 @@ export declare class OrbitMode implements NavigationMode {
     set(active: boolean): void;
     private activateOrbitControls;
 }
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
- */
-export declare class PlanMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Plan";
-    private mouseAction1?;
-    private mouseAction2?;
-    private mouseInitialized;
-    private readonly defaultAzimuthSpeed;
-    private readonly defaultPolarSpeed;
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-}
-import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
- */
-export declare class ProjectionManager {
-    /**
-     * Event that fires when the {@link CameraProjection} changes.
-     */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
-    /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
-     */
-    current: CameraProjection;
-    /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
-     */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    constructor(camera: OrthoPerspectiveCamera);
-    /**
-     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
-     *
-     * @param projection - the new projection to set. If it is the current projection,
-     * it will have no effect.
-     */
-    set(projection: CameraProjection): Promise<void>;
-    /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
-     */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
-}
-/**
- * The projection system of the camera.
- */
-export type CameraProjection = "Perspective" | "Orthographic";
-/**
- * The extensible list of supported navigation modes.
- */
-export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
-/**
- * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
- */
-export interface NavigationMode {
-    /** The unique ID of this navigation mode. */
-    id: NavModeID;
-    /**
-     * Enable or disable this navigation mode.
-     * When a new navigation mode is enabled, the previous navigation mode
-     * must be disabled.
-     *
-     * @param active - whether to enable or disable this mode.
-     * @param options - any additional data required to enable or disable it.
-     * */
-    set: (active: boolean, options?: any) => void;
-    /** Whether this navigation mode is active or not. */
-    enabled: boolean;
-}
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-}
 import * as THREE from "three";
 import * as WEBIFC from "web-ifc";
 import * as FRAGS from "@thatopen/fragments";
@@ -3348,51 +3332,6 @@ export declare class CivilReader {
     } | undefined;
     private getCurves;
 }
-/**
- * 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[];
-    }[];
-}
-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 * as WEBIFC from "web-ifc";
 import * as THREE from "three";
 export declare class Units {
@@ -3403,6 +3342,22 @@ export declare class Units {
     private getLengthUnits;
     private getScaleMatrix;
 }
+import * as WEBIFC from "web-ifc";
+export declare class IfcMetadataReader {
+    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+}
+import { IfcFragmentSettings } from "../../IfcLoader/src";
+/**
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ */
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    /**
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
+     */
+    propertiesSize: number;
+}
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
     [modelID: string]: RelationsMap;
@@ -3427,10 +3382,55 @@ 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 { BufferGeometry } from "three";
 import * as THREE from "three";
 export declare class TransformHelper {
     getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
 }
+/**
+ * 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[];
+    }[];
+}
 
 }