@thatopen/components 2.0.21 → 2.0.23

package/dist/namespace.d.ts

@@ -1,240 +1,4 @@
 declare namespace OBC {
-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.21";
-    /** {@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 * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
-/**
- * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * Return the UUIDs of all disposed components.
-     */
-    get(): Set<string>;
-    /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
-     *
-     * @param recursive - whether to recursively dispose the children of the mesh.
-     */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
-    /**
-     * Disposes a geometry from memory.
-     *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
-     */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}
-import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
-import { Components } from "../Components";
-import { SimpleWorld } from "./src";
-/**
- * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
- */
-export declare class Worlds 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: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a new world is created.
-     * The event passes the newly created world as a parameter.
-     */
-    readonly onWorldCreated: Event<World>;
-    /**
-     * An event that is triggered when a world is deleted.
-     * The event passes the UUID of the deleted world as a parameter.
-     */
-    readonly onWorldDeleted: Event<string>;
-    /**
-     * A collection of worlds managed by this component.
-     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
-     */
-    list: Map<string, World>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
-     *
-     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
-     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
-     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
-     *
-     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
-     */
-    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
-    /**
-     * Deletes a world from the list of worlds.
-     *
-     * @param {World} world - The world to be deleted.
-     *
-     * @throws {Error} - Throws an error if the provided world is not found in the list.
-     *
-     * @returns {void}
-     */
-    delete(world: World): void;
-    /**
-     * Disposes of the Worlds component and all its managed worlds.
-     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
-     * and triggers the onDisposed event.
-     *
-     * @returns {void}
-     */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(delta?: number): void | Promise<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 MeshCullerRenderer for the given world.
-     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
-     *
-     * @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, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
-    /**
-     * 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.
-     *
-     * @returns {void}
-     */
-    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";
@@ -362,165 +126,126 @@ export declare class Clipper extends Component implements Createable, Disposable
     private _onStartDragging;
     private _onEndDragging;
 }
-import { MiniMap } from "./src";
-import { Component, Updateable, World, Event, Disposable } from "../Types";
+import * as THREE from "three";
 import { Components } from "../Components";
+import { Component } from "../Types";
 /**
- * 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 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 MiniMaps extends Component implements Updateable, Disposable {
+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: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
-     */
-    list: Map<string, MiniMap>;
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
     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.
+     * 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 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 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.
      */
-    create(world: World): MiniMap;
+    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
     /**
-     * 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.
+     * Disposes a geometry from memory.
      *
-     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
-     * @returns {void}
+     * @param geometry - the
+     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+     * to remove.
      */
-    delete(id: string): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
+    disposeGeometry(geometry: THREE.BufferGeometry): void;
+    private disposeGeometryAndMaterials;
+    private disposeChildren;
+    private static disposeMaterial;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { GridConfig, SimpleGrid } from "./src";
-import { Components } from "../Components";
+import { Component, Disposable, Event } from "../Types";
 /**
- * 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).
+ * 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 Grids 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: "d1e814d5-b81c-4452-87a2-f039375e0489";
+    static readonly release = "2.0.23";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<void>;
     /**
-     * A map of world UUIDs to their corresponding grid instances.
+     * The list of components created in this app.
+     * The keys are UUIDs and the values are instances of the components.
      */
-    list: Map<string, SimpleGrid>;
+    readonly list: Map<string, Component>;
     /**
-     * The default configuration for grid creation.
+     * If disabled, the animation loop will be stopped.
+     * Default value is false.
      */
-    config: Required<GridConfig>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
     enabled: boolean;
-    constructor(components: Components);
+    private _clock;
     /**
-     * Creates a new grid for the given world.
-     * Throws an error if a grid already exists for the world.
+     * Adds a component to the list of components.
+     * Throws an error if a component with the same UUID already exists.
      *
-     * @param world - The world to create the grid for.
-     * @returns The newly created grid.
+     * @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 grid already exists for the given world.
+     * @throws Will throw an error if a component with the same UUID already exists.
+     *
+     * @internal
      */
-    create(world: World): SimpleGrid;
+    add(uuid: string, instance: Component): void;
     /**
-     * Deletes the grid associated with the given world.
-     * If a grid does not exist for the given world, this method does nothing.
+     * 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 grid.
+     * @template U - The type of the component to retrieve.
+     * @param Component - The constructor function of the component to retrieve.
      *
-     * @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 { Components } from "../Components";
-import { SimpleCamera } from "..";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
-/**
- * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
- */
-export declare class OrthoPerspectiveCamera extends SimpleCamera {
-    /**
-     * A ProjectionManager instance that manages the projection modes of the camera.
-     */
-    readonly projection: ProjectionManager;
-    /**
-     * A THREE.OrthographicCamera instance that represents the orthographic camera.
-     * This camera is used when the projection mode is set to orthographic.
-     */
-    readonly threeOrtho: THREE.OrthographicCamera;
-    /**
-     * A THREE.PerspectiveCamera instance that represents the perspective camera.
-     * This camera is used when the projection mode is set to perspective.
-     */
-    readonly threePersp: THREE.PerspectiveCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    protected _mode: NavigationMode | null;
-    private previousSize;
-    /**
-     * Getter for the current navigation mode.
-     * Throws an error if the mode is not found or the camera is not initialized.
+     * @returns The instance of the requested component.
      *
-     * @returns {NavigationMode} The current navigation mode.
+     * @throws Will throw an error if a component with the same UUID already exists.
      *
-     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
+     * @internal
      */
-    get mode(): NavigationMode;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    get<U extends Component>(Component: new (components: Components) => U): U;
+    constructor();
     /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
+     * Initializes the Components instance.
+     * This method starts the animation loop, sets the enabled flag to true,
+     * and calls the update method.
      *
-     * @param mode - The {@link NavigationMode} to set.
+     * @returns {void}
      */
-    set(mode: NavModeID): void;
+    init(): void;
     /**
-     * Make the camera view fit all the specified meshes.
+     * Disposes the memory of all the components and tools of this instance of
+     * the library. A memory leak will be created if:
      *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
-     */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
-    /**
-     * Allows or prevents all user input.
+     * - 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).
      *
-     * @param active - whether to enable or disable user inputs.
      */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
+    dispose(): void;
+    private update;
+    private static setupBVH;
 }
 import { Component, Disposable, World, Event } from "../Types";
 import { SimpleRaycaster } from "./src";
@@ -564,642 +289,1176 @@ export declare class Raycasters extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Components, Disposable, Event } from "../../core";
+import { Components } from "../Components";
+import { MeshCullerRenderer, CullerRendererSettings } from "./src";
+import { Component, Event, Disposable, World } from "../Types";
 /**
- * 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 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 BoundingBoxer extends Component implements Disposable {
-    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** {@link Disposable.onDisposed} */
+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 _absoluteMin;
-    private _absoluteMax;
-    private _meshes;
-    constructor(components: Components);
+    private _enabled;
     /**
-     * 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 map of MeshCullerRenderer instances, keyed by their world UUIDs.
      */
-    static getDimensions(bbox: THREE.Box3): {
-        width: number;
-        height: number;
-        depth: number;
-        center: THREE.Vector3;
-    };
+    list: Map<string, MeshCullerRenderer>;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(value: boolean);
+    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.
+     * Creates a new MeshCullerRenderer for the given world.
+     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
      *
-     * @example
-     * '''typescript
-     * const positiveBound = BoundingBoxer.newBound(true);
-     * console.log(positiveBound); // Output: Vector3 { x: Infinity, y: Infinity, z: Infinity }
+     * @param world - The world for which to create the MeshCullerRenderer.
+     * @param config - Optional configuration settings for the MeshCullerRenderer.
      *
-     * const negativeBound = BoundingBoxer.newBound(false);
-     * console.log(negativeBound); // Output: Vector3 { x: -Infinity, y: -Infinity, z: -Infinity }
-     * '''
+     * @returns The newly created or existing MeshCullerRenderer for the given world.
      */
-    static newBound(positive: boolean): THREE.Vector3;
+    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
     /**
-     * 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.
+     * 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.
      *
-     * @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.
+     * @param world - The world for which to delete the MeshCullerRenderer.
      *
-     * @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 } }
-     * '''
+     * @returns {void}
      */
-    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
+    delete(world: World): void;
     /** {@link Disposable.dispose} */
     dispose(): 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 {
     /**
-     * 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
-     * This method calculates the center and radius of a sphere that encompasses the entire bounding box.
-     * The center is calculated as the midpoint between the minimum and maximum bounds of the bounding box.
-     * The radius is calculated as the distance from the center to the minimum bound.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * const boundingSphere = boundingBoxer.getSphere();
-     * console.log(boundingSphere); // Output: Sphere { center: Vector3 { x: 0, y: 0, z: 0 }, radius: 10 }
-     * '''
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    getSphere(): THREE.Sphere;
+    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
     /**
-     * Returns a THREE.Mesh instance representing the bounding box.
-     *
-     * @returns A new THREE.Mesh instance representing the bounding box.
-     *
-     * @remarks
-     * This method calculates the dimensions of the bounding box using the 'getDimensions' method.
-     * It then creates a new THREE.BoxGeometry with the calculated dimensions.
-     * A new THREE.Mesh is created using the box geometry, and it is added to the '_meshes' array.
-     * The position of the mesh is set to the center of the bounding box.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * const boundingBoxMesh = boundingBoxer.getMesh();
-     * scene.add(boundingBoxMesh);
-     * '''
+     * A map of world UUIDs to their corresponding grid instances.
      */
-    getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    list: Map<string, SimpleGrid>;
     /**
-     * Resets the internal minimum and maximum vectors to positive and negative infinity, respectively.
-     * This method is used to prepare the BoundingBoxer for a new set of fragments.
-     *
-     * @remarks
-     * This method is called when a new set of fragments is added to the BoundingBoxer.
-     * It ensures that the bounding box calculations are accurate and up-to-date.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * // ...
-     * boundingBoxer.reset();
-     * '''
+     * The default configuration for grid creation.
      */
-    reset(): void;
+    config: Required<GridConfig>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
     /**
-     * Adds a FragmentsGroup to the BoundingBoxer.
-     *
-     * @param group - The FragmentsGroup to add.
+     * Creates a new grid for the given world.
+     * Throws an error if a grid already exists for the world.
      *
-     * @remarks
-     * This method iterates through each fragment in the provided FragmentsGroup,
-     * and calls the 'addMesh' method for each fragment's mesh.
+     * @param world - The world to create the grid for.
+     * @returns The newly created grid.
      *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * '''
+     * @throws Will throw an error if a grid already exists for the given world.
      */
-    add(group: FragmentsGroup): void;
+    create(world: World): SimpleGrid;
     /**
-     * Adds a mesh to the BoundingBoxer and calculates the bounding box.
+     * Deletes the grid associated with the given world.
+     * If a grid does not exist for the given world, this method does nothing.
      *
-     * @param mesh - The mesh to add. It can be an instance of THREE.InstancedMesh, THREE.Mesh, or FRAGS.CurveMesh.
-     * @param itemIDs - An optional iterable of numbers representing the item IDs.
+     * @param world - The world for which to delete the grid.
      *
      * @remarks
-     * This method calculates the bounding box of the provided mesh and updates the internal minimum and maximum vectors.
-     * If the mesh is an instance of THREE.InstancedMesh, it calculates the bounding box for each instance.
-     * If the mesh is an instance of FRAGS.FragmentMesh and itemIDs are provided, it calculates the bounding box for the specified item IDs.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.addMesh(mesh);
-     * '''
+     * 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.
      */
-    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
-    private static getFragmentBounds;
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
 }
-import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-import { Component, Disposable, Event, Components } from "../../core";
+import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
+import { Components } from "../Components";
+import { SimpleWorld } from "./src";
 /**
- * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
+ * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
  */
-export declare class Exploder extends Component implements Disposable {
+export declare class Worlds 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: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
     /**
-     * The height of the explosion animation.
-     * This property determines the vertical distance by which fragments are moved during the explosion.
-     * Default value is 10.
+     * An event that is triggered when a new world is created.
+     * The event passes the newly created world as a parameter.
      */
-    height: number;
+    readonly onWorldCreated: Event<World>;
     /**
-     * The group name used for the explosion animation.
-     * This property specifies the group of fragments that will be affected by the explosion.
-     * Default value is "storeys".
+     * An event that is triggered when a world is deleted.
+     * The event passes the UUID of the deleted world as a parameter.
      */
-    groupName: string;
+    readonly onWorldDeleted: Event<string>;
     /**
-     * A set of strings representing the exploded items.
-     * This set is used to keep track of which items have been exploded.
+     * A collection of worlds managed by this component.
+     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
      */
-    list: Set<string>;
+    list: Map<string, World>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
     /**
-     * Sets the explosion state of the fragments.
+     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
      *
-     * @param active - A boolean indicating whether to activate or deactivate the explosion.
+     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
+     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
+     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
      *
-     * @remarks
-     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
-     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
-     * If 'active' is false, the fragments are moved back to their original position.
+     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
+     */
+    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
+    /**
+     * Deletes a world from the list of worlds.
      *
-     * The method also keeps track of the exploded items using the 'list' set.
+     * @param {World} world - The world to be deleted.
      *
-     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
+     * @throws {Error} - Throws an error if the provided world is not found in the list.
+     *
+     * @returns {void}
      */
-    set(active: boolean): void;
-}
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Disposable, Component, Event, Components } from "../../core";
-/**
- * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs to their respective express IDs.
- */
-export interface Classification {
+    delete(world: World): void;
     /**
-     * A system within the classification.
-     * The key is the system name, and the value is an object representing the classes within the system.
+     * Disposes of the Worlds component and all its managed worlds.
+     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
+     * and triggers the onDisposed event.
+     *
+     * @returns {void}
      */
-    [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;
-    };
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(delta?: number): void | Promise<void>;
 }
+import { MiniMap } from "./src";
+import { Component, Updateable, World, Event, Disposable } from "../Types";
+import { Components } from "../Components";
 /**
- * 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).
+ * 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 Classifier extends Component implements Disposable {
+export declare class MiniMaps extends Component implements Updateable, Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /** {@link Component.enabled} */
     enabled: boolean;
     /**
-     * A map representing the classification systems.
-     * The key is the system name, and the value is an object representing the classes within the system.
+     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
      */
-    list: Classification;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    list: Map<string, MiniMap>;
     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.
+     * Creates a new {@link MiniMap} instance associated with the given world.
+     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
      *
-     * @param guid - The unique identifier of the fragment to be removed.
+     * @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.
      */
-    remove(guid: string): void;
+    create(world: World): MiniMap;
     /**
-     * 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.
+     * 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.
      *
-     * @throws Will throw an error if the fragments map is malformed.
+     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
+     * @returns {void}
      */
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
+    delete(id: string): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(): void;
+}
+import * as THREE from "three";
+import { Components } from "../Components";
+import { SimpleCamera } from "..";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+/**
+ * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
+ */
+export declare class OrthoPerspectiveCamera extends SimpleCamera {
     /**
-     * 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.
-     *
+     * A ProjectionManager instance that manages the projection modes of the camera.
      */
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    readonly projection: ProjectionManager;
     /**
-     * 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.
+     * A THREE.OrthographicCamera instance that represents the orthographic camera.
+     * This camera is used when the projection mode is set to orthographic.
      */
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    readonly threeOrtho: THREE.OrthographicCamera;
     /**
-     * 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.
+     * A THREE.PerspectiveCamera instance that represents the perspective camera.
+     * This camera is used when the projection mode is set to perspective.
      */
-    byEntity(group: FRAGS.FragmentsGroup): void;
+    readonly threePersp: THREE.PerspectiveCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    protected _mode: NavigationMode | null;
+    private previousSize;
     /**
-     * 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.
+     * Getter for the current navigation mode.
+     * Throws an error if the mode is not found or the camera is not initialized.
      *
-     * @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.
+     * @returns {NavigationMode} The current navigation mode.
      *
-     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
+     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
      */
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    get mode(): NavigationMode;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): 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.
+     * Sets a new {@link NavigationMode} and disables the previous one.
      *
-     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
+     * @param mode - The {@link NavigationMode} to set.
      */
-    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
+    set(mode: NavModeID): 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.
+     * Make the camera view fit all the specified meshes.
      *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
      */
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<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.
+     * Allows or prevents all user input.
      *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
+     * @param active - whether to enable or disable user inputs.
      */
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoPerspCameraAspect;
 }
 import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
+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[];
 }
-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).
+ * 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 Hider extends Component {
+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: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    static uuid: string;
     /** {@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.
+     * Utility method to calculate the distance from a point to a line segment.
      *
-     * @returns {void}
+     * @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.
      */
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
     /**
-     * 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.
+     * Method to get the face of a mesh that contains a given triangle index.
+     * It also returns the edges of the found face and their indices.
      *
-     * @returns {void}
-     */
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
-}
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
-/**
- * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
- */
-export declare class IfcLoader extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * @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.
      */
-    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
     /**
-     * An event triggered when the IFC file starts loading.
+     * 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.
      */
-    readonly onIfcStartedLoading: Event<void>;
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
     /**
-     * An event triggered when the setup process is completed.
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
+     *
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
      */
-    readonly onSetup: Event<void>;
+    round(vector: THREE.Vector3): void;
+    private getFaceData;
+}
+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";
+/**
+ * Configuration interface for the VertexPicker component.
+ */
+export interface VertexPickerConfig {
     /**
-     * The settings for the IfcLoader.
-     * It includes options for excluding categories, setting WASM paths, and more.
+     * If true, only vertices will be picked, not the closest point on the face.
      */
-    settings: IfcFragmentSettings;
+    showOnlyVertex: boolean;
     /**
-     * The instance of the Web-IFC library used for handling IFC data.
+     * The maximum distance for snapping to a vertex.
      */
-    webIfc: WEBIFC.IfcAPI;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _material;
-    private _spatialTree;
-    private _metaData;
-    private _fragmentInstances;
-    private _civil;
-    private _visitedFragments;
-    private _materialT;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    snapDistance: number;
     /**
-     * Sets up the IfcLoader component with the provided configuration.
-     *
-     * @param config - Optional configuration settings for the IfcLoader.
-     * If not provided, the existing settings will be used.
-     *
-     * @returns A Promise that resolves when the setup process is completed.
-     *
-     * @remarks
-     * If the 'autoSetWasm' option is enabled in the configuration,
-     * the method will automatically set the WASM paths for the Web-IFC library.
+     * 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.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = new IfcLoader(components);
-     * await ifcLoader.setup({ autoSetWasm: true });
-     * '''
+     * @param value - The new enabled state.
      */
-    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    set enabled(value: boolean);
     /**
-     * Loads an IFC file and processes it for 3D visualization.
+     * Gets the current enabled state of the VertexPicker.
      *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @param coordinate - Optional boolean indicating whether to coordinate the loaded IFC data. Default is true.
+     * @returns The current enabled state.
+     */
+    get enabled(): boolean;
+    /**
+     * Sets the configuration for the VertexPicker component.
      *
-     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
+     * @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
-     * const ifcLoader = components.get(IfcLoader);
-     * const group = await ifcLoader.load(ifcData);
+     * vertexPicker.config = {
+     *   snapDistance: 0.5,
+     *   showOnlyVertex: true,
+     * };
      * '''
      */
-    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
+    set config(value: Partial<VertexPickerConfig>);
     /**
-     * Reads an IFC file and initializes the Web-IFC library.
-     *
-     * @param data - The Uint8Array containing the IFC file data.
-     *
-     * @returns A Promise that resolves when the IFC file is opened and initialized.
+     * Gets the current configuration for the VertexPicker component.
      *
-     * @remarks
-     * This method sets the WASM path and initializes the Web-IFC library based on the provided settings.
-     * It also opens the IFC model using the provided data and settings.
+     * @returns A copy of the current VertexPickerConfig object.
      *
      * @example
      * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * await ifcLoader.readIfcFile(ifcData);
+     * const currentConfig = vertexPicker.config;
+     * console.log(currentConfig.snapDistance); // Output: 0.25
      * '''
      */
-    readIfcFile(data: Uint8Array): Promise<number>;
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Cleans up the IfcLoader component by resetting the Web-IFC library,
-     * clearing the visited fragments and fragment instances maps, and creating a new instance of the Web-IFC library.
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
      *
-     * @remarks
-     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
+     * @param world - The World instance to use for raycasting.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * ifcLoader.cleanUp();
-     * '''
+     * @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'.
      */
-    cleanUp(): void;
-    private getAllGeometries;
-    private getMesh;
-    private getGeometry;
-    private autoSetWasm;
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
 }
-import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
-import { Component, Components, Event, Disposable } from "../../core";
-import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
+import { Disposable, Component, Event, Components } from "../../core";
 /**
- * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
+ * 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 declare class FragmentsManager extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Event triggered when fragments are loaded.
-     */
-    readonly onFragmentsLoaded: Event<FragmentsGroup>;
-    /**
-     * Event triggered when fragments are disposed.
-     */
-    readonly onFragmentsDisposed: Event<{
-        groupID: string;
-        fragmentIDs: string[];
-    }>;
+export interface Classification {
     /**
-     * Map containing all loaded fragments.
-     * The key is the fragment's unique identifier, and the value is the fragment itself.
+     * A system within the classification.
+     * The key is the system name, and the value is an object representing the classes within the system.
      */
-    readonly list: Map<string, Fragment>;
+    [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;
+    };
+}
+/**
+ * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
+ */
+export declare class Classifier extends Component implements Disposable {
     /**
-     * Map containing all loaded fragment groups.
-     * The key is the group's unique identifier, and the value is the group itself.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    readonly groups: Map<string, FragmentsGroup>;
-    baseCoordinationModel: string;
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
     /** {@link Component.enabled} */
     enabled: boolean;
-    private _loader;
     /**
-     * Getter for the meshes of all fragments in the FragmentsManager.
-     * It iterates over the fragments in the list and pushes their meshes into an array.
-     * @returns {THREE.Mesh[]} An array of THREE.Mesh objects representing the fragments.
+     * A map representing the classification systems.
+     * The key is the system name, and the value is an object representing the classes within the system.
      */
-    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
+    list: Classification;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     constructor(components: Components);
+    private onFragmentsDisposed;
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
-     * Dispose of a specific fragment group.
-     * This method removes the group from the groups map, deletes all fragments within the group from the list,
-     * disposes of the group, and triggers the onFragmentsDisposed event.
+     * 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 group - The fragment group to be disposed.
-     */
-    disposeGroup(group: FragmentsGroup): void;
-    /**
-     * Loads a binary file that contain fragment geometry.
-     * @param data - The binary data to load.
-     * @param config - Optional configuration for loading.
-     * @param config.coordinate - Whether to apply coordinate transformation. Default is true.
-     * @param config.properties - Ifc properties to set on the loaded fragments. Not to be used when streaming.
-     * @returns The loaded FragmentsGroup.
+     * @param guid - The unique identifier of the fragment to be removed.
      */
-    load(data: Uint8Array, config?: Partial<{
-        coordinate: boolean;
-        name: string;
-        properties: FRAGS.IfcProperties;
-        relationsMap: RelationsMap;
-    }>): FragmentsGroup;
+    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.
+     *
+     */
+    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 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
+     * This method calculates the center and radius of a sphere that encompasses the entire bounding box.
+     * The center is calculated as the midpoint between the minimum and maximum bounds of the bounding box.
+     * The radius is calculated as the distance from the center to the minimum bound.
+     *
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.add(fragmentsGroup);
+     * const boundingSphere = boundingBoxer.getSphere();
+     * console.log(boundingSphere); // Output: Sphere { center: Vector3 { x: 0, y: 0, z: 0 }, radius: 10 }
+     * '''
+     */
+    getSphere(): THREE.Sphere;
+    /**
+     * Returns a THREE.Mesh instance representing the bounding box.
+     *
+     * @returns A new THREE.Mesh instance representing the bounding box.
+     *
+     * @remarks
+     * This method calculates the dimensions of the bounding box using the 'getDimensions' method.
+     * It then creates a new THREE.BoxGeometry with the calculated dimensions.
+     * A new THREE.Mesh is created using the box geometry, and it is added to the '_meshes' array.
+     * The position of the mesh is set to the center of the bounding box.
+     *
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.add(fragmentsGroup);
+     * const boundingBoxMesh = boundingBoxer.getMesh();
+     * scene.add(boundingBoxMesh);
+     * '''
+     */
+    getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    /**
+     * Resets the internal minimum and maximum vectors to positive and negative infinity, respectively.
+     * This method is used to prepare the BoundingBoxer for a new set of fragments.
+     *
+     * @remarks
+     * This method is called when a new set of fragments is added to the BoundingBoxer.
+     * It ensures that the bounding box calculations are accurate and up-to-date.
+     *
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.add(fragmentsGroup);
+     * // ...
+     * boundingBoxer.reset();
+     * '''
+     */
+    reset(): void;
+    /**
+     * Adds a FragmentsGroup to the BoundingBoxer.
+     *
+     * @param group - The FragmentsGroup to add.
+     *
+     * @remarks
+     * This method iterates through each fragment in the provided FragmentsGroup,
+     * and calls the 'addMesh' method for each fragment's mesh.
+     *
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.add(fragmentsGroup);
+     * '''
+     */
+    add(group: FragmentsGroup): void;
+    /**
+     * Adds a mesh to the BoundingBoxer and calculates the bounding box.
+     *
+     * @param mesh - The mesh to add. It can be an instance of THREE.InstancedMesh, THREE.Mesh, or FRAGS.CurveMesh.
+     * @param itemIDs - An optional iterable of numbers representing the item IDs.
+     *
+     * @remarks
+     * This method calculates the bounding box of the provided mesh and updates the internal minimum and maximum vectors.
+     * If the mesh is an instance of THREE.InstancedMesh, it calculates the bounding box for each instance.
+     * If the mesh is an instance of FRAGS.FragmentMesh and itemIDs are provided, it calculates the bounding box for the specified item IDs.
+     *
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.addMesh(mesh);
+     * '''
+     */
+    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
+    private static getFragmentBounds;
+}
+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 { Component, Disposable, Event, Components } from "../../core";
+/**
+ * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
+ */
+export declare class Exploder extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * The height of the explosion animation.
+     * This property determines the vertical distance by which fragments are moved during the explosion.
+     * Default value is 10.
+     */
+    height: number;
+    /**
+     * The group name used for the explosion animation.
+     * This property specifies the group of fragments that will be affected by the explosion.
+     * Default value is "storeys".
+     */
+    groupName: string;
+    /**
+     * A set of strings representing the exploded items.
+     * This set is used to keep track of which items have been exploded.
+     */
+    list: Set<string>;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets the explosion state of the fragments.
+     *
+     * @param active - A boolean indicating whether to activate or deactivate the explosion.
+     *
+     * @remarks
+     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
+     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
+     * If 'active' is false, the fragments are moved back to their original position.
+     *
+     * The method also keeps track of the exploded items using the 'list' set.
+     *
+     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
+     */
+    set(active: boolean): void;
+}
+import * as WEBIFC from "web-ifc";
+import { AsyncEvent, Component, Disposable, Event } from "../../core";
+import { PropertiesStreamingSettings } from "./src";
+/**
+ * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
+ */
+export declare class IfcPropertiesTiler extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    /**
+     * An event that is triggered when properties are streamed from the IFC file.
+     * The event provides the type of the IFC entity and the corresponding data.
+     */
+    readonly onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
+        };
+    }>;
+    /**
+     * An event that is triggered to indicate the progress of the streaming process.
+     * The event provides a number between 0 and 1 representing the progress percentage.
+     */
+    readonly onProgress: AsyncEvent<number>;
+    /**
+     * An event that is triggered when indices are streamed from the IFC file.
+     * The event provides a map of indices, where the key is the entity type and the value is another map of indices.
+     */
+    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
+     */
+    settings: PropertiesStreamingSettings;
+    /**
+     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
+     */
+    webIfc: WEBIFC.IfcAPI;
+    /** {@link Disposable.dispose} */
+    dispose(): Promise<void>;
+    /**
+     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
+     */
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    /**
+     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
+     *
+     * @param loadCallback - A callback function that loads the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
+     */
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private cleanUp;
+}
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
+/**
+ * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
+ */
+export declare class IfcLoader extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * An event triggered when the IFC file starts loading.
+     */
+    readonly onIfcStartedLoading: Event<void>;
+    /**
+     * An event triggered when the setup process is completed.
+     */
+    readonly onSetup: Event<void>;
+    /**
+     * The settings for the IfcLoader.
+     * It includes options for excluding categories, setting WASM paths, and more.
+     */
+    settings: IfcFragmentSettings;
+    /**
+     * The instance of the Web-IFC library used for handling IFC data.
+     */
+    webIfc: WEBIFC.IfcAPI;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    private _material;
+    private _spatialTree;
+    private _metaData;
+    private _fragmentInstances;
+    private _civil;
+    private _visitedFragments;
+    private _materialT;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets up the IfcLoader component with the provided configuration.
+     *
+     * @param config - Optional configuration settings for the IfcLoader.
+     * If not provided, the existing settings will be used.
+     *
+     * @returns A Promise that resolves when the setup process is completed.
+     *
+     * @remarks
+     * If the 'autoSetWasm' option is enabled in the configuration,
+     * the method will automatically set the WASM paths for the Web-IFC library.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = new IfcLoader(components);
+     * await ifcLoader.setup({ autoSetWasm: true });
+     * '''
+     */
+    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    /**
+     * Loads an IFC file and processes it for 3D visualization.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     * @param coordinate - Optional boolean indicating whether to coordinate the loaded IFC data. Default is true.
+     *
+     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * const group = await ifcLoader.load(ifcData);
+     * '''
+     */
+    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
+    /**
+     * Reads an IFC file and initializes the Web-IFC library.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     *
+     * @returns A Promise that resolves when the IFC file is opened and initialized.
+     *
+     * @remarks
+     * This method sets the WASM path and initializes the Web-IFC library based on the provided settings.
+     * It also opens the IFC model using the provided data and settings.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * await ifcLoader.readIfcFile(ifcData);
+     * '''
+     */
+    readIfcFile(data: Uint8Array): Promise<number>;
+    /**
+     * Cleans up the IfcLoader component by resetting the Web-IFC library,
+     * clearing the visited fragments and fragment instances maps, and creating a new instance of the Web-IFC library.
+     *
+     * @remarks
+     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * ifcLoader.cleanUp();
+     * '''
+     */
+    cleanUp(): void;
+    private getAllGeometries;
+    private getMesh;
+    private getGeometry;
+    private autoSetWasm;
+}
+import { Fragment, FragmentsGroup } from "@thatopen/fragments";
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components, Event, Disposable } from "../../core";
+import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
+/**
+ * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
+ */
+export declare class FragmentsManager extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Event triggered when fragments are loaded.
+     */
+    readonly onFragmentsLoaded: Event<FragmentsGroup>;
+    /**
+     * Event triggered when fragments are disposed.
+     */
+    readonly onFragmentsDisposed: Event<{
+        groupID: string;
+        fragmentIDs: string[];
+    }>;
+    /**
+     * Map containing all loaded fragments.
+     * The key is the fragment's unique identifier, and the value is the fragment itself.
+     */
+    readonly list: Map<string, Fragment>;
+    /**
+     * Map containing all loaded fragment groups.
+     * The key is the group's unique identifier, and the value is the group itself.
+     */
+    readonly groups: Map<string, FragmentsGroup>;
+    baseCoordinationModel: string;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    private _loader;
+    /**
+     * Getter for the meshes of all fragments in the FragmentsManager.
+     * It iterates over the fragments in the list and pushes their meshes into an array.
+     * @returns {THREE.Mesh[]} An array of THREE.Mesh objects representing the fragments.
+     */
+    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Dispose of a specific fragment group.
+     * This method removes the group from the groups map, deletes all fragments within the group from the list,
+     * disposes of the group, and triggers the onFragmentsDisposed event.
+     *
+     * @param group - The fragment group to be disposed.
+     */
+    disposeGroup(group: FragmentsGroup): void;
+    /**
+     * Loads a binary file that contain fragment geometry.
+     * @param data - The binary data to load.
+     * @param config - Optional configuration for loading.
+     * @param config.coordinate - Whether to apply coordinate transformation. Default is true.
+     * @param config.properties - Ifc properties to set on the loaded fragments. Not to be used when streaming.
+     * @returns The loaded FragmentsGroup.
+     */
+    load(data: Uint8Array, config?: Partial<{
+        coordinate: boolean;
+        name: string;
+        properties: FRAGS.IfcProperties;
+        relationsMap: RelationsMap;
+    }>): FragmentsGroup;
     /**
      * Export the specified fragmentsgroup to binary data.
      * @param group - the fragments group to be exported.
@@ -1291,117 +1550,52 @@ export declare class IfcGeometryTiler extends Component implements Disposable {
     private _metaData;
     private _visitedGeometries;
     private _streamSerializer;
-    private _geometries;
-    private _geometryCount;
-    private _civil;
-    private _groupSerializer;
-    private _assets;
-    private _meshesWithHoles;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * This method streams the IFC file from a given buffer.
-     *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @returns A Promise that resolves when the streaming process is complete.
-     *
-     * @remarks
-     * This method cleans up any resources after the streaming process is complete.
-     *
-     * @example
-     * '''typescript
-     * const ifcData = await fetch('path/to/ifc/file.ifc');
-     * const rawBuffer = await response.arrayBuffer();
-     * const ifcBuffer = new Uint8Array(rawBuffer);
-     * await ifcGeometryTiler.streamFromBuffer(ifcBuffer);
-     * '''
-     */
-    streamFromBuffer(data: Uint8Array): Promise<void>;
-    /**
-     * This method streams the IFC file from a given callback.
-     *
-     * @param loadCallback - The callback function that will be used to load the IFC file.
-     * @returns A Promise that resolves when the streaming process is complete.
-     *
-     * @remarks
-     * This method cleans up any resources after the streaming process is complete.
-     *
-     */
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllGeometries;
-    private cleanUp;
-    private getMesh;
-    private getGeometry;
-    private streamAssets;
-    private streamGeometries;
-}
-import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../core";
-import { PropertiesStreamingSettings } from "./src";
-/**
- * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
- */
-export declare class IfcPropertiesTiler extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
-    /**
-     * An event that is triggered when properties are streamed from the IFC file.
-     * The event provides the type of the IFC entity and the corresponding data.
-     */
-    readonly onPropertiesStreamed: AsyncEvent<{
-        type: number;
-        data: {
-            [id: number]: any;
-        };
-    }>;
-    /**
-     * An event that is triggered to indicate the progress of the streaming process.
-     * The event provides a number between 0 and 1 representing the progress percentage.
-     */
-    readonly onProgress: AsyncEvent<number>;
-    /**
-     * An event that is triggered when indices are streamed from the IFC file.
-     * The event provides a map of indices, where the key is the entity type and the value is another map of indices.
-     */
-    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
-     */
-    settings: PropertiesStreamingSettings;
-    /**
-     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
-     */
-    webIfc: WEBIFC.IfcAPI;
+    private _geometries;
+    private _geometryCount;
+    private _civil;
+    private _groupSerializer;
+    private _assets;
+    private _meshesWithHoles;
+    constructor(components: Components);
     /** {@link Disposable.dispose} */
-    dispose(): Promise<void>;
+    dispose(): void;
     /**
-     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
+     * This method streams the IFC file from a given buffer.
      *
      * @param data - The Uint8Array containing the IFC file data.
      * @returns A Promise that resolves when the streaming process is complete.
+     *
+     * @remarks
+     * This method cleans up any resources after the streaming process is complete.
+     *
+     * @example
+     * '''typescript
+     * const ifcData = await fetch('path/to/ifc/file.ifc');
+     * const rawBuffer = await response.arrayBuffer();
+     * const ifcBuffer = new Uint8Array(rawBuffer);
+     * await ifcGeometryTiler.streamFromBuffer(ifcBuffer);
+     * '''
      */
     streamFromBuffer(data: Uint8Array): Promise<void>;
     /**
-     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
+     * This method streams the IFC file from a given callback.
      *
-     * @param loadCallback - A callback function that loads the IFC file data.
+     * @param loadCallback - The callback function that will be used to load the IFC file.
      * @returns A Promise that resolves when the streaming process is complete.
+     *
+     * @remarks
+     * This method cleans up any resources after the streaming process is complete.
+     *
      */
     streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
     private readIfcFile;
     private streamIfcFile;
-    private streamAllProperties;
+    private streamAllGeometries;
     private cleanUp;
+    private getMesh;
+    private getGeometry;
+    private streamAssets;
+    private streamGeometries;
 }
 import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
@@ -1545,31 +1739,6 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     dispose(): void;
 }
 import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
- */
-export declare class IfcJsonExporter extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
-     */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
-}
-import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Component, Disposable, Event, Components } from "../../core";
 /**
@@ -1825,204 +1994,31 @@ 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 {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Utility method to calculate the distance from a point to a line segment.
-     *
-     * @param point - The point from which to calculate the distance.
-     * @param lineStart - The start point of the line segment.
-     * @param lineEnd - The end point of the line segment.
-     * @param clamp - If true, the distance will be clamped to the line segment's length.
-     * @returns The distance from the point to the line segment.
-     */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    /**
-     * Method to get the face of a mesh that contains a given triangle index.
-     * It also returns the edges of the found face and their indices.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param triangleIndex - The index of the triangle within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
-     */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
-     */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
-     *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
-     */
-    round(vector: THREE.Vector3): void;
-    private getFaceData;
-}
-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";
-/**
- * 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 WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
 /**
- * A Set of unique numbers representing different types of IFC geometries.
+ * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
  */
-export declare const GeometryTypes: Set<number>;
+export declare class IfcJsonExporter extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
+     */
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+}
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
 /**
@@ -2112,11 +2108,18 @@ 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;
-}>;
+/**
+ * A Set of unique numbers representing different types of IFC geometries.
+ */
+export declare const GeometryTypes: Set<number>;
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
+}
 import * as WEBIFC from "web-ifc";
 /** Configuration of the IFC-fragment conversion. */
 export declare class IfcFragmentSettings {
@@ -2159,14 +2162,6 @@ export declare class IfcFragmentSettings {
     customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
 }
 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";
 export interface IfcItemsCategories {
     [itemID: number]: number;
 }
@@ -2215,937 +2210,893 @@ export declare class IfcPropertiesUtils {
     static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
     static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
 }
-/**
- * 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;
-}
-/**
- * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
- */
-export declare class Event<T> {
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
-     */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
-     */
-    remove(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => void;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}
 import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Event } from "./event";
-/**
- * Whether this component has to be manually destroyed once you are done with it to prevent [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects). This also ensures that the DOM events created by that component will be cleaned up.
- */
-export interface Disposable {
-    /**
-     * Destroys the object from memory to prevent a
-     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
-     */
-    dispose: () => void | Promise<void>;
-    /** Fired after the tool has been disposed.  */
-    readonly onDisposed: Event<any>;
-}
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
 /**
- * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
+ * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
+ *
+ * @template T - The type of the scene. Default is BaseScene.
+ * @template U - The type of the camera. Default is BaseCamera.
+ * @template S - The type of the renderer. Default is BaseRenderer.
  */
-export interface Hideable {
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
     /**
-     * Whether the geometric representation of this component is
-     * currently visible or not in the
-     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
      */
-    visible: boolean;
-}
-/**
- * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
- */
-export interface Resizeable {
+    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>;
     /**
-     * Sets size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
+     * 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.
      */
-    resize: (size?: THREE.Vector2) => void;
-    /** Event that fires when the component has been resized. */
-    onResize: Event<THREE.Vector2>;
+    isDisposing: boolean;
     /**
-     * Gets the current size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
+     * Indicates whether the world is currently enabled.
+     * When disabled, the world will not be updated.
      */
-    getSize: () => THREE.Vector2;
-}
-/** Whether this component should be updated each frame. */
-export interface Updateable {
-    /** Actions that should be executed after updating the component. */
-    onAfterUpdate: Event<any>;
-    /** Actions that should be executed before updating the component. */
-    onBeforeUpdate: Event<any>;
+    enabled: boolean;
     /**
-     * Function used to update the state of this component each frame. For
-     * instance, a renderer component will make a render each frame.
+     * A unique identifier for the world.
      */
-    update(delta?: number): void;
-}
-/** Basic type to describe the progress of any kind of process. */
-export interface Progress {
-    /** The amount of things that have been done already. */
-    current: number;
-    /** The total amount of things to be done by the process. */
-    total: number;
-}
-/**
- * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
- */
-export interface Createable {
-    /** Creates a new instance of an element (e.g. a new Dimension). */
-    create: (data: any) => void;
+    uuid: string;
     /**
-     * Finish the creation process of the component, successfully creating an
-     * instance of whatever the component creates.
+     * An optional name for the world.
      */
-    endCreation?: (data: any) => void;
+    name?: string;
+    private _scene?;
+    private _camera?;
+    private _renderer;
     /**
-     * Cancels the creation process of the component, going back to the state
-     * before starting to create.
-     */
-    cancelCreation?: (data: any) => void;
-    /** Deletes an existing instance of an element (e.g. a Dimension). */
-    delete: (data: any) => void;
-}
-/**
- * Whether this component supports to be configured.
- */
-export interface Configurable<T extends Record<string, any>> {
-    /** Wether this components has been already configured. */
-    isSetup: boolean;
-    /** Use the provided configuration to setup the tool. */
-    setup: (config?: Partial<T>) => void | Promise<void>;
-    /** Fired after successfully calling {@link Configurable.setup()}  */
-    readonly onSetup: Event<any>;
-    /** Object holding the tool configuration. Is not meant to be edited directly, if you need
-     * to make changes to this object, use {@link Configurable.setup()} just after the tool is instantiated.
+     * Getter for the scene. If no scene is initialized, it throws an error.
+     * @returns The current scene.
      */
-    config: Required<T>;
-}
-/**
- * Whether a camera uses the Camera Controls library.
- */
-export interface CameraControllable {
+    get scene(): T;
     /**
-     * An instance of CameraControls that provides camera control functionalities.
-     * This instance is used to manipulate the camera.
-     */
-    controls: CameraControls;
-}
-import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
-import { Components } from "../../Components";
-/**
- * Base class of the library. Useful for finding out the interfaces something implements.
- */
-export declare abstract class Base {
-    components: Components;
-    constructor(components: Components);
-    /** Whether is component is {@link Disposable}. */
-    isDisposeable: () => this is Disposable;
-    /** Whether is component is {@link Resizeable}. */
-    isResizeable: () => this is Resizeable;
-    /** Whether is component is {@link Updateable}. */
-    isUpdateable: () => this is Updateable;
-    /** Whether is component is {@link Hideable}. */
-    isHideable: () => this is Hideable;
-    /** Whether is component is {@link Configurable}. */
-    isConfigurable: () => this is Configurable<any>;
-}
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { BaseWorldItem } from "./base-world-item";
-import { CameraControllable } from "./interfaces";
-/**
- * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
- */
-export declare abstract class BaseCamera extends BaseWorldItem {
+     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
+     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
+     * @param scene - The new scene to be set.
+     */
+    set scene(scene: T);
     /**
-     * Whether the camera is enabled or not.
+     * Getter for the camera. If no camera is initialized, it throws an error.
+     * @returns The current camera.
      */
-    abstract enabled: boolean;
+    get camera(): U;
     /**
-     * The Three.js camera instance.
+     * 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.
      */
-    abstract three: THREE.Camera;
+    set camera(camera: U);
     /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
+     * 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).
      */
-    abstract controls?: CameraControls;
+    get renderer(): S | null;
     /**
-     * Checks whether the instance is {@link CameraControllable}.
-     *
-     * @returns True if the instance is controllable, false otherwise.
+     * 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.
      */
-    hasCameraControls: () => this is CameraControllable;
+    set renderer(renderer: S | null);
+    /** {@link Updateable.update} */
+    update(delta?: number): void;
+    /** {@link Disposable.dispose} */
+    dispose(disposeResources?: boolean): void;
 }
-import { Base } from "./base";
+import * as THREE from "three";
+import { BaseScene, Configurable, Event } from "../../Types";
+import { Components } from "../../Components";
 /**
- * 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.
+ * Configuration interface for the {@link SimpleScene}. Defines properties for directional and ambient lights.
  */
-export declare abstract class Component extends Base {
+export interface SimpleSceneConfig {
+    directionalLight: {
+        color: THREE.Color;
+        intensity: number;
+        position: THREE.Vector3;
+    };
+    ambientLight: {
+        color: THREE.Color;
+        intensity: number;
+    };
+}
+/**
+ * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add objects hierarchically, and easily dispose them when you are finished with it.
+ */
+export declare class SimpleScene extends BaseScene implements Configurable<{}> {
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
     /**
-     * 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.
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
      */
-    abstract enabled: boolean;
+    three: THREE.Scene;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<SimpleScene>;
+    /**
+     * Configuration interface for the {@link SimpleScene}.
+     * Defines properties for directional and ambient lights.
+     */
+    config: Required<SimpleSceneConfig>;
+    constructor(components: Components);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleSceneConfig>): void;
 }
 import * as THREE from "three";
-import { Vector2 } from "three";
-import { Event } from "./event";
-import { BaseWorldItem } from "./base-world-item";
-import { Disposable, Resizeable, Updateable } from "./interfaces";
+import { BaseRenderer, Event } from "../../Types";
+import { Components } from "../../Components";
 /**
- * Abstract class representing a renderer for a 3D world. All renderers should use this class as a base.
+ * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
  */
-export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
+export declare class SimpleRenderer extends BaseRenderer {
     /**
-     * The three.js WebGLRenderer instance associated with this renderer.
-     *
-     * @abstract
-     * @type {THREE.WebGLRenderer}
+     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
+     * Default is 'true'.
      */
-    abstract three: THREE.WebGLRenderer;
-    /** {@link Updateable.onBeforeUpdate} */
-    onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<undefined>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
+    enabled: boolean;
     /**
-     * Event that fires when there has been a change to the list of clipping
-     * planes used by the active renderer.
+     * The HTML container of the THREE.js canvas where the scene is rendered.
      */
-    readonly onClippingPlanesUpdated: Event<unknown>;
-    /** {@link Updateable.update} */
-    abstract update(delta?: number): void | Promise<void>;
-    /** {@link Disposable.dispose} */
-    abstract dispose(): void;
-    /** {@link Resizeable.getSize} */
-    abstract getSize(): Vector2;
-    /** {@link Resizeable.resize} */
-    abstract resize(size: Vector2 | undefined): void;
+    container: HTMLElement;
     /**
-     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
+     * The THREE.js WebGLRenderer instance.
      */
-    clippingPlanes: THREE.Plane[];
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<unknown>;
+    private _resizing;
     /**
-     * Updates the clipping planes and triggers the 'onClippingPlanesUpdated' event.
+     * Constructor for the SimpleRenderer class.
      *
-     * @remarks
-     * This method is typically called when there is a change to the list of clipping planes
-     * used by the active renderer.
+     * @param components - The components instance.
+     * @param container - The HTML container where the THREE.js canvas will be rendered.
+     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
      */
-    updateClippingPlanes(): void;
+    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
+    /** {@link Updateable.update} */
+    update(): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Resizeable.getSize}. */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize: (size?: THREE.Vector2) => void;
     /**
-     * Sets or removes a clipping plane from the renderer.
+     * Sets up and manages the event listeners for the renderer.
      *
-     * @param active - A boolean indicating whether the clipping plane should be active or not.
-     * @param plane - The clipping plane to be added or removed.
-     * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to 'false'.
+     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
      *
-     * @remarks
-     * This method adds or removes a clipping plane from the 'clippingPlanes' array.
-     * If 'active' is 'true' and the plane is not already in the array, it is added.
-     * If 'active' is 'false' and the plane is in the array, it is removed.
-     * The 'three.clippingPlanes' property is then updated to reflect the current state of the 'clippingPlanes' array,
-     * excluding any planes marked as local.
+     * @throws Will throw an error if the renderer does not have an HTML container.
      */
-    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
+    setupEvents(active: boolean): void;
+    private resizeEvent;
+    private setupRenderer;
+    private onContextLost;
+    private onContextBack;
 }
 import * as THREE from "three";
-import { Disposable } from "./interfaces";
-import { Event } from "./event";
-import { Components } from "../../Components";
-import { BaseWorldItem } from "./base-world-item";
-/**
- * Abstract class representing a base scene in the application. All scenes should use this class as a base.
- */
-export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Abstract property representing the three.js object associated with this scene.
-     * It should be implemented by subclasses.
-     */
-    abstract three: THREE.Object3D;
-    protected constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}
-import { Base } from "./base";
-import { World } from "./world";
-import { Event } from "./event";
+import CameraControls from "camera-controls";
+import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
 import { Components } from "../../Components";
 /**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
- */
-export declare abstract class BaseWorldItem extends Base {
-    readonly worlds: Map<string, World>;
-    /**
-     * Event that is triggered when a world is added or removed from the 'worlds' map.
-     * The event payload contains the world instance and the action ("added" or "removed").
-     */
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
-    }>;
-    /**
-     * The current world this item is associated with. It can be null if no world is currently active.
-     */
-    currentWorld: World | null;
-    protected constructor(components: Components);
-}
-import * as THREE from "three";
-import { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
-/**
- * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
+ * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
  */
-export interface World extends Disposable, Updateable {
+export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<SimpleCamera>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<SimpleCamera>;
     /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
+     * Event that is triggered when the aspect of the camera has been updated.
+     * This event is useful when you need to perform actions after the aspect of the camera has been changed.
      */
-    meshes: Set<THREE.Mesh>;
+    readonly onAspectUpdated: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * The base scene of the world.
+     * A three.js PerspectiveCamera or OrthographicCamera instance.
+     * This camera is used for rendering the scene.
      */
-    scene: BaseScene;
+    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    private _allControls;
     /**
-     * The base camera of the world.
+     * The object that controls the camera. An instance of
+     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
+     * Transforming the camera directly will have no effect: you need to use this
+     * object to move, rotate, look at objects, etc.
      */
-    camera: BaseCamera;
+    get controls(): CameraControls;
     /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
+     * Getter for the enabled state of the camera controls.
+     * If the current world is null, it returns false.
+     * Otherwise, it returns the enabled state of the camera controls.
+     *
+     * @returns {boolean} The enabled state of the camera controls.
      */
-    renderer: BaseRenderer | null;
+    get enabled(): boolean;
     /**
-     * A unique identifier for the world.
+     * Setter for the enabled state of the camera controls.
+     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
+     *
+     * @param {boolean} enabled - The new enabled state of the camera controls.
      */
-    uuid: string;
+    set enabled(enabled: boolean);
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(_delta: number): void;
     /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
      */
-    isDisposing: boolean;
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
 }
 import * as THREE from "three";
-import { Hideable, Event, World, Disposable } from "../../Types";
-import { Components } from "../../Components";
+import CameraControls from "camera-controls";
+import { Event } from "./event";
 /**
- * Configuration interface for the {@link SimpleGrid} class.
+ * Whether this component has to be manually destroyed once you are done with it to prevent [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects). This also ensures that the DOM events created by that component will be cleaned up.
  */
-export interface GridConfig {
-    /**
-     * The color of the grid lines.
-     */
-    color: THREE.Color;
-    /**
-     * The size of the primary grid lines.
-     */
-    size1: number;
+export interface Disposable {
     /**
-     * The size of the secondary grid lines.
+     * Destroys the object from memory to prevent a
+     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
      */
-    size2: number;
+    dispose: () => void | Promise<void>;
+    /** Fired after the tool has been disposed.  */
+    readonly onDisposed: Event<any>;
+}
+/**
+ * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
+ */
+export interface Hideable {
     /**
-     * The distance at which the grid lines start to fade away.
+     * Whether the geometric representation of this component is
+     * currently visible or not in the
+     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
      */
-    distance: number;
+    visible: boolean;
 }
 /**
- * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
  */
-export 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;
+export interface Resizeable {
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Sets size of this component (e.g. the resolution of a
+     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+     * component.
      */
-    get fade(): boolean;
+    resize: (size?: THREE.Vector2) => void;
+    /** Event that fires when the component has been resized. */
+    onResize: Event<THREE.Vector2>;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Gets the current size of this component (e.g. the resolution of a
+     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+     * component.
      */
-    set fade(active: boolean);
-    /** The Three.js mesh that contains the infinite grid. */
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World, config: GridConfig);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
+    getSize: () => THREE.Vector2;
+}
+/** Whether this component should be updated each frame. */
+export interface Updateable {
+    /** Actions that should be executed after updating the component. */
+    onAfterUpdate: Event<any>;
+    /** Actions that should be executed before updating the component. */
+    onBeforeUpdate: Event<any>;
+    /**
+     * Function used to update the state of this component each frame. For
+     * instance, a renderer component will make a render each frame.
+     */
+    update(delta?: number): void;
+}
+/** Basic type to describe the progress of any kind of process. */
+export interface Progress {
+    /** The amount of things that have been done already. */
+    current: number;
+    /** The total amount of things to be done by the process. */
+    total: number;
 }
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { AsyncEvent, Event, World } from "../../Types";
 /**
- * Settings to configure the CullerRenderer.
+ * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
  */
-export interface CullerRendererSettings {
+export interface Createable {
+    /** Creates a new instance of an element (e.g. a new Dimension). */
+    create: (data: any) => void;
     /**
-     * Interval in milliseconds at which the visibility check should be performed.
-     * Default value is 1000.
+     * Finish the creation process of the component, successfully creating an
+     * instance of whatever the component creates.
      */
-    updateInterval?: number;
+    endCreation?: (data: any) => void;
     /**
-     * Width of the render target used for visibility checks.
-     * Default value is 512.
+     * Cancels the creation process of the component, going back to the state
+     * before starting to create.
      */
-    width?: number;
-    /**
-     * Height of the render target used for visibility checks.
-     * Default value is 512.
+    cancelCreation?: (data: any) => void;
+    /** Deletes an existing instance of an element (e.g. a Dimension). */
+    delete: (data: any) => void;
+}
+/**
+ * Whether this component supports to be configured.
+ */
+export interface Configurable<T extends Record<string, any>> {
+    /** Wether this components has been already configured. */
+    isSetup: boolean;
+    /** Use the provided configuration to setup the tool. */
+    setup: (config?: Partial<T>) => void | Promise<void>;
+    /** Fired after successfully calling {@link Configurable.setup()}  */
+    readonly onSetup: Event<any>;
+    /** Object holding the tool configuration. Is not meant to be edited directly, if you need
+     * to make changes to this object, use {@link Configurable.setup()} just after the tool is instantiated.
      */
-    height?: number;
+    config: Required<T>;
+}
+/**
+ * Whether a camera uses the Camera Controls library.
+ */
+export interface CameraControllable {
     /**
-     * Whether the visibility check should be performed automatically.
-     * Default value is true.
+     * An instance of CameraControls that provides camera control functionalities.
+     * This instance is used to manipulate the camera.
      */
-    autoUpdate?: boolean;
+    controls: CameraControls;
 }
 /**
- * A base renderer to determine visibility on screen.
+ * 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 CullerRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+export declare class Event<T> {
     /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
+    add(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
     /**
-     * Whether this renderer is active or not. If not, it won't render anything.
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
      */
-    enabled: boolean;
+    remove(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => void;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
+}
+import { Base } from "./base";
+/**
+ * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
+ */
+export declare abstract class Component extends Base {
     /**
-     * Needs to check whether there are objects that need to be hidden or shown.
-     * You can bind this to the camera movement, to a certain interval, etc.
+     * 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.
      */
-    needsUpdate: boolean;
+    abstract enabled: boolean;
+}
+import { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<number, {
+    forRelating: InverseAttribute;
+    forRelated: InverseAttribute;
+}>;
+/**
+ * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
+ */
+export declare class AsyncEvent<T> {
     /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    renderDebugFrame: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /** The world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected autoUpdate: boolean;
-    protected updateInterval: number;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _width;
-    private _height;
-    private _availableColor;
-    private readonly renderTarget;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    add(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
     /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
      */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-    private applySettings;
+    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;
 }
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
-import { IfcFragmentSettings } from "../../IfcLoader/src";
+import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
+import { Components } from "../../Components";
 /**
- * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ * Base class of the library. Useful for finding out the interfaces something implements.
  */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
-    /**
-     * Amount of properties to be streamed.
-     * Defaults to 100 properties.
-     */
-    propertiesSize: number;
+export declare abstract class Base {
+    components: Components;
+    constructor(components: Components);
+    /** Whether is component is {@link Disposable}. */
+    isDisposeable: () => this is Disposable;
+    /** Whether is component is {@link Resizeable}. */
+    isResizeable: () => this is Resizeable;
+    /** Whether is component is {@link Updateable}. */
+    isUpdateable: () => this is Updateable;
+    /** Whether is component is {@link Hideable}. */
+    isHideable: () => this is Hideable;
+    /** Whether is component is {@link Configurable}. */
+    isConfigurable: () => this is Configurable<any>;
 }
-import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
+import { Base } from "./base";
+import { World } from "./world";
+import { Event } from "./event";
 import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
 /**
- * A renderer to hide/show meshes depending on their visibility from the user's point of view.
+ * One of the elements that make a world. It can be either a scene, a camera or a renderer.
  */
-export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
+export declare abstract class BaseWorldItem extends Base {
+    readonly worlds: Map<string, World>;
     /**
-     * Event triggered when the visibility of meshes is updated.
-     * Contains two sets: seen and unseen.
+     * Event that is triggered when a world is added or removed from the 'worlds' map.
+     * The event payload contains the world instance and the action ("added" or "removed").
      */
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
     }>;
     /**
-     * Pixels in screen a geometry must occupy to be considered "seen".
-     * Default value is 100.
+     * The current world this item is associated with. It can be null if no world is currently active.
      */
-    threshold: number;
+    currentWorld: World | null;
+    protected constructor(components: Components);
+}
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { BaseWorldItem } from "./base-world-item";
+import { CameraControllable } from "./interfaces";
+/**
+ * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
+ */
+export declare abstract class BaseCamera extends BaseWorldItem {
     /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
+     * Whether the camera is enabled or not.
      */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    abstract enabled: boolean;
     /**
-     * Flag to indicate if the renderer is currently processing.
-     * Used to prevent concurrent processing.
+     * The Three.js camera instance.
      */
-    isProcessing: boolean;
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private _intervalID;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    abstract three: THREE.Camera;
     /**
-     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
-     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
+     * Optional CameraControls instance for controlling the camera.
+     * This property is only available if the camera is controllable.
      */
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    abstract controls?: CameraControls;
     /**
-     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
-     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
-     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
+     * Checks whether the instance is {@link CameraControllable}.
+     *
+     * @returns True if the instance is controllable, false otherwise.
      */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
+    hasCameraControls: () => this is CameraControllable;
 }
 import * as THREE from "three";
-import { Hideable, Disposable, Event, World } from "../../Types";
-import { Components } from "../../Components";
+import { Vector2 } from "three";
+import { Event } from "./event";
+import { BaseWorldItem } from "./base-world-item";
+import { Disposable, Resizeable, Updateable } from "./interfaces";
 /**
- * Each of the clipping planes created by the clipper.
+ * Abstract class representing a renderer for a 3D world. All renderers should use this class as a base.
  */
-export declare class SimplePlane implements Disposable, Hideable {
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onDraggingStarted: Event<unknown>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onDraggingEnded: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * The normal vector of the clipping plane.
-     */
-    readonly normal: THREE.Vector3;
-    /**
-     * The origin point of the clipping plane.
-     */
-    readonly origin: THREE.Vector3;
+export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
     /**
-     * The THREE.js Plane object representing the clipping plane.
+     * The three.js WebGLRenderer instance associated with this renderer.
+     *
+     * @abstract
+     * @type {THREE.WebGLRenderer}
      */
-    readonly three: THREE.Plane;
-    /** The components instance to which this plane belongs. */
-    components: Components;
-    /** The world instance to which this plane belongs. */
-    world: World;
-    protected readonly _helper: THREE.Object3D;
-    protected _visible: boolean;
-    protected _enabled: boolean;
-    private _controlsActive;
-    private readonly _arrowBoundBox;
-    private readonly _planeMesh;
-    private readonly _controls;
-    private readonly _hiddenMaterial;
+    abstract three: THREE.WebGLRenderer;
+    /** {@link Updateable.onBeforeUpdate} */
+    onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onAfterUpdate} */
+    onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<undefined>;
+    /** {@link Resizeable.onResize} */
+    readonly onResize: Event<THREE.Vector2>;
     /**
-     * Getter for the enabled state of the clipping plane.
-     * @returns {boolean} The current enabled state.
+     * Event that fires when there has been a change to the list of clipping
+     * planes used by the active renderer.
      */
-    get enabled(): boolean;
+    readonly onClippingPlanesUpdated: Event<unknown>;
+    /** {@link Updateable.update} */
+    abstract update(delta?: number): void | Promise<void>;
+    /** {@link Disposable.dispose} */
+    abstract dispose(): void;
+    /** {@link Resizeable.getSize} */
+    abstract getSize(): Vector2;
+    /** {@link Resizeable.resize} */
+    abstract resize(size: Vector2 | undefined): void;
     /**
-     * Setter for the enabled state of the clipping plane.
-     * Updates the clipping plane state in the renderer and throws an error if no renderer is found.
-     * @param {boolean} state - The new enabled state.
+     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
      */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The meshes used for raycasting */
-    get meshes(): THREE.Mesh[];
-    /** The material of the clipping plane representation. */
-    get planeMaterial(): THREE.Material | THREE.Material[];
-    /** The material of the clipping plane representation. */
-    set planeMaterial(material: THREE.Material | THREE.Material[]);
-    /** The size of the clipping plane representation. */
-    get size(): number;
-    /** Sets the size of the clipping plane representation. */
-    set size(size: number);
+    clippingPlanes: THREE.Plane[];
     /**
-     * Getter for the helper object of the clipping plane.
-     * The helper object is a THREE.Object3D that contains the clipping plane mesh and other related objects.
-     * It is used for positioning, rotating, and scaling the clipping plane in the 3D scene.
+     * Updates the clipping planes and triggers the 'onClippingPlanesUpdated' event.
      *
-     * @returns {THREE.Object3D} The helper object of the clipping plane.
+     * @remarks
+     * This method is typically called when there is a change to the list of clipping planes
+     * used by the active renderer.
      */
-    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
-    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
+    updateClippingPlanes(): void;
     /**
-     * Sets the clipping plane's normal and origin from the given normal and point.
-     * This method resets the clipping plane's state, updates the normal and origin,
-     * and positions the helper object accordingly.
+     * Sets or removes a clipping plane from the renderer.
      *
-     * @param normal - The new normal vector for the clipping plane.
-     * @param point - The new origin point for the clipping plane.
+     * @param active - A boolean indicating whether the clipping plane should be active or not.
+     * @param plane - The clipping plane to be added or removed.
+     * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to 'false'.
      *
-     * @returns {void}
+     * @remarks
+     * This method adds or removes a clipping plane from the 'clippingPlanes' array.
+     * If 'active' is 'true' and the plane is not already in the array, it is added.
+     * If 'active' is 'false' and the plane is in the array, it is removed.
+     * The 'three.clippingPlanes' property is then updated to reflect the current state of the 'clippingPlanes' array,
+     * excluding any planes marked as local.
      */
-    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): void;
-    /** {@link Updateable.update} */
-    update: () => void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private reset;
-    protected toggleControls(state: boolean): void;
-    private newTransformControls;
-    private initializeControls;
-    private createArrowBoundingBox;
-    private changeDrag;
-    private notifyDraggingChanged;
-    private preventCameraMovement;
-    private newHelper;
-    private static newPlaneMesh;
+    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }
 import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+import { Disposable } from "./interfaces";
+import { Event } from "./event";
+import { Components } from "../../Components";
+import { BaseWorldItem } from "./base-world-item";
 /**
- * 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.
+ * Abstract class representing a base scene in the application. All scenes should use this class as a base.
  */
-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>;
+export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
     /** {@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.
+     * Abstract property representing the three.js object associated with this scene.
+     * It should be implemented by subclasses.
      */
-    isDisposing: boolean;
+    abstract three: THREE.Object3D;
+    protected constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+}
+import * as THREE from "three";
+import { BaseScene } from "./base-scene";
+import { BaseCamera } from "./base-camera";
+import { BaseRenderer } from "./base-renderer";
+import { Updateable, Disposable } from "./interfaces";
+/**
+ * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
+ */
+export interface World extends Disposable, Updateable {
     /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
+     * A set of meshes present in the world. This is taken into account for operations like raycasting.
      */
-    enabled: boolean;
+    meshes: Set<THREE.Mesh>;
     /**
-     * A unique identifier for the world.
+     * The base scene of the world.
      */
-    uuid: string;
+    scene: BaseScene;
     /**
-     * An optional name for the world.
+     * The base camera of the world.
      */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
+    camera: BaseCamera;
     /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
+     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
      */
-    get scene(): T;
+    renderer: BaseRenderer | null;
     /**
-     * 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.
+     * A unique identifier for the world.
      */
-    set scene(scene: T);
+    uuid: string;
     /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
+     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
      */
-    get camera(): U;
+    isDisposing: boolean;
+}
+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;
     /**
-     * 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.
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
      */
-    set camera(camera: U);
+    readonly three: THREE.Raycaster;
     /**
-     * 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).
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
      */
-    get renderer(): S | null;
+    world: World;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * 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.
+     * 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}.
      */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
-    /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
+    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    /**
+     * Casts a ray from a given origin in a given direction and returns the first item found.
+     * This method also takes into account the clipping planes used by the renderer.
+     *
+     * @param origin - The origin of the ray.
+     * @param direction - The direction of the ray.
+     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
+     * @returns The first intersection found or 'null' if no intersection was found.
+     */
+    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
+    private intersect;
+    private filterClippingPlanes;
 }
 import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
+import { Hideable, Event, World, Disposable } from "../../Types";
 import { Components } from "../../Components";
 /**
- * Configuration interface for the {@link SimpleScene}. Defines properties for directional and ambient lights.
+ * Configuration interface for the {@link SimpleGrid} class.
  */
-export interface SimpleSceneConfig {
-    directionalLight: {
-        color: THREE.Color;
-        intensity: number;
-        position: THREE.Vector3;
-    };
-    ambientLight: {
-        color: THREE.Color;
-        intensity: number;
-    };
+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;
 }
 /**
- * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add objects hierarchically, and easily dispose them when you are finished with it.
+ * 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 SimpleScene extends BaseScene implements Configurable<{}> {
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
+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;
     /**
-     * The underlying Three.js scene object.
-     * It is used to define the 3D space containing objects, lights, and cameras.
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    three: THREE.Scene;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<SimpleScene>;
+    get fade(): boolean;
     /**
-     * Configuration interface for the {@link SimpleScene}.
-     * Defines properties for directional and ambient lights.
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    config: Required<SimpleSceneConfig>;
-    constructor(components: Components);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): 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(): void;
+    private setupEvents;
+    private updateZoom;
 }
 import * as THREE from "three";
-import { BaseRenderer, Event } from "../../Types";
+import { Disposable, Event } from "../../Types";
+/**
+ * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
+ */
+export declare class Mouse implements Disposable {
+    dom: HTMLCanvasElement;
+    private _event?;
+    private _position;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    constructor(dom: HTMLCanvasElement);
+    /**
+     * The real position of the mouse of the Three.js canvas.
+     */
+    get position(): THREE.Vector2;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private getPositionY;
+    private getPositionX;
+    private updateMouseInfo;
+    private setupEvents;
+}
+import * as THREE from "three";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
 import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
 /**
- * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
  */
-export declare class SimpleRenderer extends BaseRenderer {
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
-     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
-     * Default is 'true'.
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
      */
-    enabled: boolean;
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
     /**
-     * The HTML container of the THREE.js canvas where the scene is rendered.
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
      */
-    container: HTMLElement;
+    threshold: number;
     /**
-     * The THREE.js WebGLRenderer instance.
+     * Map of color code to THREE.InstancedMesh.
+     * Used to keep track of color-coded meshes.
      */
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /**
-     * Constructor for the SimpleRenderer class.
-     *
-     * @param components - The components instance.
-     * @param container - The HTML container where the THREE.js canvas will be rendered.
-     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
+     * Flag to indicate if the renderer is currently processing.
+     * Used to prevent concurrent processing.
      */
-    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
-    /** {@link Updateable.update} */
-    update(): void;
+    isProcessing: boolean;
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private _intervalID;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@link Resizeable.getSize}. */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize: (size?: THREE.Vector2) => void;
     /**
-     * Sets up and manages the event listeners for the renderer.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
-     *
-     * @throws Will throw an error if the renderer does not have an HTML container.
+     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
+     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
      */
-    setupEvents(active: boolean): void;
-    private resizeEvent;
-    private setupRenderer;
-    private onContextLost;
-    private onContextBack;
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    /**
+     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
+     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
+     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
+     */
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
 }
 import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
 import { Components } from "../../Components";
+import { AsyncEvent, Event, World } from "../../Types";
 /**
- * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
+ * Settings to configure the CullerRenderer.
  */
-export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<SimpleCamera>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<SimpleCamera>;
+export interface CullerRendererSettings {
     /**
-     * Event that is triggered when the aspect of the camera has been updated.
-     * This event is useful when you need to perform actions after the aspect of the camera has been changed.
+     * Interval in milliseconds at which the visibility check should be performed.
+     * Default value is 1000.
      */
-    readonly onAspectUpdated: Event<unknown>;
+    updateInterval?: number;
+    /**
+     * Width of the render target used for visibility checks.
+     * Default value is 512.
+     */
+    width?: number;
+    /**
+     * Height of the render target used for visibility checks.
+     * Default value is 512.
+     */
+    height?: number;
+    /**
+     * Whether the visibility check should be performed automatically.
+     * Default value is true.
+     */
+    autoUpdate?: boolean;
+}
+/**
+ * A base renderer to determine visibility on screen.
+ */
+export declare class CullerRenderer {
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
     /**
-     * A three.js PerspectiveCamera or OrthographicCamera instance.
-     * This camera is used for rendering the scene.
+     * Fires after making the visibility check to the meshes. It lists the
+     * meshes that are currently visible, and the ones that were visible
+     * just before but not anymore.
      */
-    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    private _allControls;
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
     /**
-     * The object that controls the camera. An instance of
-     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
-     * Transforming the camera directly will have no effect: you need to use this
-     * object to move, rotate, look at objects, etc.
+     * Whether this renderer is active or not. If not, it won't render anything.
      */
-    get controls(): CameraControls;
+    enabled: boolean;
     /**
-     * Getter for the enabled state of the camera controls.
-     * If the current world is null, it returns false.
-     * Otherwise, it returns the enabled state of the camera controls.
-     *
-     * @returns {boolean} The enabled state of the camera controls.
+     * Needs to check whether there are objects that need to be hidden or shown.
+     * You can bind this to the camera movement, to a certain interval, etc.
      */
-    get enabled(): boolean;
+    needsUpdate: boolean;
     /**
-     * Setter for the enabled state of the camera controls.
-     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
-     *
-     * @param {boolean} enabled - The new enabled state of the camera controls.
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
      */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected autoUpdate: boolean;
+    protected updateInterval: number;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _width;
+    private _height;
+    private _availableColor;
+    private readonly renderTarget;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
     /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
      */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
-}
-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;
+    updateVisibility: (force?: boolean) => Promise<void>;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
+    private applySettings;
 }
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
@@ -3165,22 +3116,63 @@ export declare class OrbitMode implements NavigationMode {
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
+ * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
  */
-export declare class PlanMode implements NavigationMode {
+export declare class FirstPersonMode 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;
+    readonly id = "FirstPerson";
     constructor(camera: OrthoPerspectiveCamera);
     /** {@link NavigationMode.set} */
     set(active: boolean): void;
+    private setupFirstPersonCamera;
+}
+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.
@@ -3208,66 +3200,122 @@ export interface NavigationMode {
     /** Whether this navigation mode is active or not. */
     enabled: boolean;
 }
-import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../Types";
+import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
  */
-export declare class ProjectionManager {
+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 { Hideable, Disposable, Event, World } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * Each of the clipping planes created by the clipper.
+ */
+export declare class SimplePlane implements Disposable, Hideable {
+    /** Event that fires when the user starts dragging a clipping plane. */
+    readonly onDraggingStarted: Event<unknown>;
+    /** Event that fires when the user stops dragging a clipping plane. */
+    readonly onDraggingEnded: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * Event that fires when the {@link CameraProjection} changes.
+     * The normal vector of the clipping plane.
      */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
-    /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
+    readonly normal: THREE.Vector3;
+    /**
+     * The origin point of the clipping plane.
      */
-    current: CameraProjection;
+    readonly origin: THREE.Vector3;
     /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     * The THREE.js Plane object representing the clipping plane.
      */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    constructor(camera: OrthoPerspectiveCamera);
+    readonly three: THREE.Plane;
+    /** The components instance to which this plane belongs. */
+    components: Components;
+    /** The world instance to which this plane belongs. */
+    world: World;
+    protected readonly _helper: THREE.Object3D;
+    protected _visible: boolean;
+    protected _enabled: boolean;
+    private _controlsActive;
+    private readonly _arrowBoundBox;
+    private readonly _planeMesh;
+    private readonly _controls;
+    private readonly _hiddenMaterial;
     /**
-     * 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.
+     * Getter for the enabled state of the clipping plane.
+     * @returns {boolean} The current enabled state.
      */
-    set(projection: CameraProjection): Promise<void>;
+    get enabled(): boolean;
     /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
+     * Setter for the enabled state of the clipping plane.
+     * Updates the clipping plane state in the renderer and throws an error if no renderer is found.
+     * @param {boolean} state - The new enabled state.
      */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
-}
-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 {
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The meshes used for raycasting */
+    get meshes(): THREE.Mesh[];
+    /** The material of the clipping plane representation. */
+    get planeMaterial(): THREE.Material | THREE.Material[];
+    /** The material of the clipping plane representation. */
+    set planeMaterial(material: THREE.Material | THREE.Material[]);
+    /** The size of the clipping plane representation. */
+    get size(): number;
+    /** Sets the size of the clipping plane representation. */
+    set size(size: number);
     /**
-     * Minimum number of geometries to be streamed.
-     * Defaults to 10 geometries.
+     * Getter for the helper object of the clipping plane.
+     * The helper object is a THREE.Object3D that contains the clipping plane mesh and other related objects.
+     * It is used for positioning, rotating, and scaling the clipping plane in the 3D scene.
+     *
+     * @returns {THREE.Object3D} The helper object of the clipping plane.
      */
-    minGeometrySize: number;
+    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
+    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
     /**
-     * Minimum amount of assets to be streamed.
-     * Defaults to 1000 assets.
+     * Sets the clipping plane's normal and origin from the given normal and point.
+     * This method resets the clipping plane's state, updates the normal and origin,
+     * and positions the helper object accordingly.
+     *
+     * @param normal - The new normal vector for the clipping plane.
+     * @param point - The new origin point for the clipping plane.
+     *
+     * @returns {void}
      */
-    minAssetsSize: number;
+    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): void;
+    /** {@link Updateable.update} */
+    update: () => void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private reset;
+    protected toggleControls(state: boolean): void;
+    private newTransformControls;
+    private initializeControls;
+    private createArrowBoundingBox;
+    private changeDrag;
+    private notifyDraggingChanged;
+    private preventCameraMovement;
+    private newHelper;
+    private static newPlaneMesh;
 }
 import * as THREE from "three";
 import * as WEBIFC from "web-ifc";
@@ -3284,114 +3332,37 @@ export declare class CivilReader {
     } | undefined;
     private getCurves;
 }
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-}
-/**
- * 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 * as THREE from "three";
-import { Disposable, Event } from "../../Types";
+import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
- * 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.
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
  */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
     /**
-     * The real position of the mouse of the Three.js canvas.
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
      */
-    get position(): THREE.Vector2;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private setupEvents;
+    propertiesSize: number;
 }
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
+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";
 /**
- * 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.
+ * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
  */
-export declare class SimpleRaycaster implements Disposable {
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** The components instance to which this Raycaster belongs. */
-    components: Components;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The position of the mouse in the screen. */
-    readonly mouse: Mouse;
-    /**
-     * A reference to the Three.js Raycaster instance.
-     * This is used for raycasting operations.
-     */
-    readonly three: THREE.Raycaster;
-    /**
-     * A reference to the world instance to which this Raycaster belongs.
-     * This is used to access the camera and meshes.
-     */
-    world: World;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
     /**
-     * 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}.
+     * Minimum number of geometries to be streamed.
+     * Defaults to 10 geometries.
      */
-    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    minGeometrySize: number;
     /**
-     * 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.
+     * Minimum amount of assets to be streamed.
+     * Defaults to 1000 assets.
      */
-    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;
+    minAssetsSize: number;
 }
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
@@ -3417,6 +3388,11 @@ export type InverseAttributes = [
     "ContainsElements"
 ];
 export type InverseAttribute = InverseAttributes[number];
+import { BufferGeometry } from "three";
+import * as THREE from "three";
+export declare class TransformHelper {
+    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
+}
 import * as WEBIFC from "web-ifc";
 import * as THREE from "three";
 export declare class Units {
@@ -3427,10 +3403,34 @@ export declare class Units {
     private getLengthUnits;
     private getScaleMatrix;
 }
-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[];
+    }[];
 }
 
 }