@thatopen/components 2.3.12 → 2.3.14

package/dist/namespace.d.ts

@@ -1,4 +1,97 @@
 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.3.14";
+    /** {@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;
+    /**
+     * Event that triggers the Components instance is initialized.
+     *
+     * @remarks
+     * This event is triggered once when the {@link Components.init} method has been called and finish processing.
+     * This is useful to set configuration placeholders that need to be executed when the components instance is initialized.
+     * For example, enabling and configuring custom effects in a post-production renderer.
+     *
+     * @example
+     * '''typescript
+     * const components = new Components();
+     * components.onInit.add(() => {
+     *   // Enable custom effects in the post-production renderer
+     *   // or any other operation dependant on the component initialization
+     * });
+     * components.init();
+     * '''
+     */
+    readonly onInit: Event<undefined>;
+    /**
+     * 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.
+     */
+    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";
@@ -44,6 +137,48 @@ export declare class Disposer extends Component {
     private disposeChildren;
     private static disposeMaterial;
 }
+import { Component, Disposable, World, Event } from "../Types";
+import { SimpleRaycaster } from "./src";
+import { Components } from "../Components";
+/**
+ * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
+ */
+export declare class Raycasters extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * A Map that stores raycasters for each world.
+     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     */
+    list: Map<string, SimpleRaycaster>;
+    /** {@link Disposable.onDisposed} */
+    onDisposed: Event<unknown>;
+    constructor(components: Components);
+    /**
+     * Retrieves a SimpleRaycaster instance for the given world.
+     * If a SimpleRaycaster instance already exists for the world, it will be returned.
+     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
+     *
+     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
+     * @returns The SimpleRaycaster instance for the given world.
+     */
+    get(world: World): SimpleRaycaster;
+    /**
+     * Deletes the SimpleRaycaster instance associated with the given world.
+     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
+     *
+     * @param world - The world for which to delete the SimpleRaycaster instance.
+     * @returns {void}
+     */
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+}
 import { SimpleScene, SimpleSceneConfig, SimpleSceneConfigManager } from "../Worlds";
 import { DistanceRenderer } from "./src";
 import { Configurable, Disposable } from "../Types";
@@ -147,207 +282,72 @@ export declare class Grids extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
+import * as THREE from "three";
+import { Component, Configurable, Createable, Disposable, Event, Hideable, World } from "../Types";
+import { SimplePlane } from "./src";
 import { Components } from "../Components";
+import { ClipperConfig, ClipperConfigManager } from "./src/clipper-config";
 /**
- * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
+ * A lightweight component to easily create, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
+ *
+ * @param components - the instance of {@link Components} used.
+ * E.g. {@link SimplePlane}.
  */
-export declare class Raycasters extends Component implements Disposable {
+export declare class Clipper extends Component implements Createable, Disposable, Hideable, Configurable<ClipperConfigManager, ClipperConfig> {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** Event that fires when the user starts dragging a clipping plane. */
+    readonly onBeforeDrag: Event<void>;
+    /** Event that fires when the user stops dragging a clipping plane. */
+    readonly onAfterDrag: Event<void>;
     /**
-     * A Map that stores raycasters for each world.
-     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     * Event that fires when the user starts creating a clipping plane.
      */
-    list: Map<string, SimpleRaycaster>;
-    /** {@link Disposable.onDisposed} */
-    onDisposed: Event<unknown>;
-    constructor(components: Components);
+    readonly onBeforeCreate: Event<unknown>;
     /**
-     * Retrieves a SimpleRaycaster instance for the given world.
-     * If a SimpleRaycaster instance already exists for the world, it will be returned.
-     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
-     *
-     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
-     * @returns The SimpleRaycaster instance for the given world.
+     * Event that fires when the user cancels the creation of a clipping plane.
      */
-    get(world: World): SimpleRaycaster;
+    readonly onBeforeCancel: Event<unknown>;
     /**
-     * Deletes the SimpleRaycaster instance associated with the given world.
-     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
-     *
-     * @param world - The world for which to delete the SimpleRaycaster instance.
-     * @returns {void}
+     * Event that fires after the user cancels the creation of a clipping plane.
      */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}
-import { Component, Disposable, Event } from "../Types";
-/**
- * The entry point of the Components library. It can create, delete and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
- */
-export declare class Components implements Disposable {
+    readonly onAfterCancel: Event<unknown>;
     /**
-     * The version of the @thatopen/components library.
+     * Event that fires when the user starts deleting a clipping plane.
      */
-    static readonly release = "2.3.12";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<void>;
+    readonly onBeforeDelete: Event<unknown>;
     /**
-     * The list of components created in this app.
-     * The keys are UUIDs and the values are instances of the components.
+     * Event that fires after a clipping plane has been created.
+     * @param plane - The newly created clipping plane.
      */
-    readonly list: Map<string, Component>;
+    readonly onAfterCreate: Event<SimplePlane>;
     /**
-     * If disabled, the animation loop will be stopped.
-     * Default value is false.
+     * Event that fires after a clipping plane has been deleted.
+     * @param plane - The deleted clipping plane.
      */
-    enabled: boolean;
-    private _clock;
+    readonly onAfterDelete: Event<SimplePlane>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
     /**
-     * Event that triggers the Components instance is initialized.
-     *
-     * @remarks
-     * This event is triggered once when the {@link Components.init} method has been called and finish processing.
-     * This is useful to set configuration placeholders that need to be executed when the components instance is initialized.
-     * For example, enabling and configuring custom effects in a post-production renderer.
-     *
-     * @example
-     * '''typescript
-     * const components = new Components();
-     * components.onInit.add(() => {
-     *   // Enable custom effects in the post-production renderer
-     *   // or any other operation dependant on the component initialization
-     * });
-     * components.init();
-     * '''
+     * Whether to force the clipping plane to be orthogonal in the Y direction
+     * (up). This is desirable when clipping a building horizontally and a
+     * clipping plane is created in its roof, which might have a slight
+     * slope for draining purposes.
      */
-    readonly onInit: Event<undefined>;
+    orthogonalY: boolean;
     /**
-     * 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
+     * The tolerance that determines whether an almost-horizontal clipping plane
+     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
+     * has to be 'true' for this to apply.
      */
-    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.
-     */
-    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 { Component, Configurable, Createable, Disposable, Event, Hideable, World } from "../Types";
-import { SimplePlane } from "./src";
-import { Components } from "../Components";
-import { ClipperConfig, ClipperConfigManager } from "./src/clipper-config";
-/**
- * A lightweight component to easily create, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
- *
- * @param components - the instance of {@link Components} used.
- * E.g. {@link SimplePlane}.
- */
-export declare class Clipper extends Component implements Createable, Disposable, Hideable, Configurable<ClipperConfigManager, ClipperConfig> {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onBeforeDrag: Event<void>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onAfterDrag: Event<void>;
-    /**
-     * Event that fires when the user starts creating a clipping plane.
-     */
-    readonly onBeforeCreate: Event<unknown>;
-    /**
-     * Event that fires when the user cancels the creation of a clipping plane.
-     */
-    readonly onBeforeCancel: Event<unknown>;
-    /**
-     * Event that fires after the user cancels the creation of a clipping plane.
-     */
-    readonly onAfterCancel: Event<unknown>;
-    /**
-     * Event that fires when the user starts deleting a clipping plane.
-     */
-    readonly onBeforeDelete: Event<unknown>;
-    /**
-     * Event that fires after a clipping plane has been created.
-     * @param plane - The newly created clipping plane.
-     */
-    readonly onAfterCreate: Event<SimplePlane>;
-    /**
-     * Event that fires after a clipping plane has been deleted.
-     * @param plane - The deleted clipping plane.
-     */
-    readonly onAfterDelete: Event<SimplePlane>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /**
-     * Whether to force the clipping plane to be orthogonal in the Y direction
-     * (up). This is desirable when clipping a building horizontally and a
-     * clipping plane is created in its roof, which might have a slight
-     * slope for draining purposes.
-     */
-    orthogonalY: boolean;
-    /**
-     * The tolerance that determines whether an almost-horizontal clipping plane
-     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
-     * has to be 'true' for this to apply.
-     */
-    toleranceOrthogonalY: number;
+    toleranceOrthogonalY: number;
     /**
      * The type of clipping plane to be created.
      * Default is {@link SimplePlane}.
@@ -531,82 +531,6 @@ export declare class Cullers extends Component implements Disposable {
      */
     updateInstanced(meshes: Iterable<THREE.InstancedMesh>): 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 {NavigationMode} The current navigation mode.
-     *
-     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
-     */
-    get mode(): NavigationMode;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
-     *
-     * @param mode - The {@link NavigationMode} to set.
-     */
-    set(mode: NavModeID): void;
-    /**
-     * Make the camera view fit all the specified meshes.
-     *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
-     */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
-    /**
-     * Allows or prevents all user input.
-     *
-     * @param active - whether to enable or disable user inputs.
-     */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
-}
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
-import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
 import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
 import { Components } from "../Components";
 import { BCFViewpoint, Viewpoint } from "./src";
@@ -644,26 +568,6 @@ export declare class Viewpoints extends Component implements Disposable, Configu
      */
     dispose(): void;
 }
-import { Component, DataMap } from "../Types";
-import { Components } from "../Components";
-import { Configurator } from "./src";
-/**
- * A tool to manage all the configuration from the app centrally.
- */
-export declare class ConfigManager extends Component {
-    /**
-     * The list of all configurations of this app.
-     */
-    list: DataMap<string, Configurator<any, any>>;
-    /** {@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: "b8c764e0-6b24-4e77-9a32-35fa728ee5b4";
-    constructor(components: Components);
-}
 import { MiniMap } from "./src";
 import { Component, Updateable, World, Event, Disposable } from "../Types";
 import { Components } from "../Components";
@@ -713,65 +617,210 @@ export declare class MiniMaps extends Component implements Updateable, Disposabl
     /** {@link Updateable.update} */
     update(): void;
 }
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
+import { Component, DataMap } from "../Types";
+import { Components } from "../Components";
+import { Configurator } from "./src";
 /**
- * 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).
+ * A tool to manage all the configuration from the app centrally.
  */
-export declare class Hider extends Component {
+export declare class ConfigManager extends Component {
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * The list of all configurations of this app.
      */
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    list: DataMap<string, Configurator<any, any>>;
     /** {@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}
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
-}
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
+    static readonly uuid: "b8c764e0-6b24-4e77-9a32-35fa728ee5b4";
+    constructor(components: Components);
 }
 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 { SimpleCamera } from "..";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
 /**
- * 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 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 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;
+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 {NavigationMode} The current navigation mode.
+     *
+     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
+     */
+    get mode(): NavigationMode;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets a new {@link NavigationMode} and disables the previous one.
+     *
+     * @param mode - The {@link NavigationMode} to set.
+     */
+    set(mode: NavModeID): void;
+    /**
+     * Make the camera view fit all the specified meshes.
+     *
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
+     */
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    /**
+     * Allows or prevents all user input.
+     *
+     * @param active - whether to enable or disable user inputs.
+     */
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoPerspCameraAspect;
+}
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Represents an edge measurement result.
+ */
+export interface MeasureEdge {
+    /**
+     * The distance between the two points of the edge.
+     */
+    distance: number;
+    /**
+     * The two points that define the edge.
+     */
+    points: THREE.Vector3[];
+}
+/**
+ * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
+ */
+export declare class MeasurementUtils extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static uuid: string;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Utility method to calculate the distance from a point to a line segment.
+     *
+     * @param point - The point from which to calculate the distance.
+     * @param lineStart - The start point of the line segment.
+     * @param lineEnd - The end point of the line segment.
+     * @param clamp - If true, the distance will be clamped to the line segment's length.
+     * @returns The distance from the point to the line segment.
+     */
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    /**
+     * Method to get the face of a mesh that contains a given triangle index.
+     * It also returns the edges of the found face and their indices.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param triangleIndex - The index of the triangle within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
+     */
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    /**
+     * Method to get the vertices and normal of a mesh face at a given index.
+     * It also applies instance transformation if provided.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param faceIndex - The index of the face within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the vertices and normal of the face.
+     * @throws Will throw an error if the geometry is not indexed.
+     */
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    /**
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
+     *
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
+     */
+    round(vector: THREE.Vector3): void;
+    /**
+     * Calculates the volume of a set of fragments.
+     *
+     * @param frags - A map of fragment IDs to their corresponding item IDs.
+     * @returns The total volume of the fragments and the bounding sphere.
+     *
+     * @remarks
+     * This method creates a set of instanced meshes from the given fragments and item IDs.
+     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
+     *
+     * @throws Will throw an error if the geometry of the meshes is not indexed.
+     * @throws Will throw an error if the fragment manager is not available.
+     */
+    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    /**
+     * Calculates the total volume of a set of meshes.
+     *
+     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
+     * @returns The total volume of the meshes and the bounding sphere.
+     *
+     * @remarks
+     * This method calculates the volume of each mesh in the provided array and returns the total volume
+     * and its bounding sphere.
+     *
+     */
+    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
+    private getFaceData;
+    private getVolumeOfMesh;
+    private getSignedVolumeOfTriangle;
+}
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Components, Disposable, Event } from "../../core";
+/**
+ * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but it's fast, and should suffice for general use cases such as camera zooming or general boundary determination. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/BoundingBoxer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/BoundingBoxer).
+ */
+export declare class BoundingBoxer extends Component implements Disposable {
+    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    private _absoluteMin;
+    private _absoluteMax;
     private _meshes;
     constructor(components: Components);
     /**
@@ -1189,120 +1238,43 @@ export declare class Classifier extends Component implements Disposable {
     resetColor(items: FRAGS.FragmentIdMap): void;
     protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
 }
-import * as WEBIFC from "web-ifc";
 import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
+import { Components, Component } 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).
+ * 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 IfcLoader extends Component implements Disposable {
+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: "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;
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
     /** {@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.
+     * Sets the visibility of fragments within the 3D scene.
+     * If no 'items' parameter is provided, all fragments will be set to the specified visibility.
+     * If 'items' is provided, only the specified fragments will be affected.
      *
-     * @remarks
-     * If the 'autoSetWasm' option is enabled in the configuration,
-     * the method will automatically set the WASM paths for the Web-IFC library.
+     * @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.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = new IfcLoader(components);
-     * await ifcLoader.setup({ autoSetWasm: true });
-     * '''
+     * @returns {void}
      */
-    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): 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.
+     * 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.
      *
-     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
+     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
+     * If not provided, all fragments will be isolated.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * const group = await ifcLoader.load(ifcData);
-     * '''
+     * @returns {void}
      */
-    load(data: Uint8Array, coordinate?: boolean, name?: string): 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;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
 }
 import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
@@ -1457,6 +1429,121 @@ export declare class FragmentsManager extends Component implements Disposable {
     clone(model: FRAGS.FragmentsGroup, items?: FRAGS.FragmentIdMap): FragmentsGroup;
 }
 import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
+/**
+ * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
+ */
+export declare class IfcLoader extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * An event triggered when the IFC file starts loading.
+     */
+    readonly onIfcStartedLoading: Event<void>;
+    /**
+     * An event triggered when the setup process is completed.
+     */
+    readonly onSetup: Event<void>;
+    /**
+     * The settings for the IfcLoader.
+     * It includes options for excluding categories, setting WASM paths, and more.
+     */
+    settings: IfcFragmentSettings;
+    /**
+     * The instance of the Web-IFC library used for handling IFC data.
+     */
+    webIfc: WEBIFC.IfcAPI;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    private _material;
+    private _spatialTree;
+    private _metaData;
+    private _fragmentInstances;
+    private _civil;
+    private _visitedFragments;
+    private _materialT;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets up the IfcLoader component with the provided configuration.
+     *
+     * @param config - Optional configuration settings for the IfcLoader.
+     * If not provided, the existing settings will be used.
+     *
+     * @returns A Promise that resolves when the setup process is completed.
+     *
+     * @remarks
+     * If the 'autoSetWasm' option is enabled in the configuration,
+     * the method will automatically set the WASM paths for the Web-IFC library.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = new IfcLoader(components);
+     * await ifcLoader.setup({ autoSetWasm: true });
+     * '''
+     */
+    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    /**
+     * Loads an IFC file and processes it for 3D visualization.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     * @param coordinate - Optional boolean indicating whether to coordinate the loaded IFC data. Default is true.
+     *
+     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * const group = await ifcLoader.load(ifcData);
+     * '''
+     */
+    load(data: Uint8Array, coordinate?: boolean, name?: string): Promise<FRAGS.FragmentsGroup>;
+    /**
+     * Reads an IFC file and initializes the Web-IFC library.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     *
+     * @returns A Promise that resolves when the IFC file is opened and initialized.
+     *
+     * @remarks
+     * This method sets the WASM path and initializes the Web-IFC library based on the provided settings.
+     * It also opens the IFC model using the provided data and settings.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * await ifcLoader.readIfcFile(ifcData);
+     * '''
+     */
+    readIfcFile(data: Uint8Array): Promise<number>;
+    /**
+     * Cleans up the IfcLoader component by resetting the Web-IFC library,
+     * clearing the visited fragments and fragment instances maps, and creating a new instance of the Web-IFC library.
+     *
+     * @remarks
+     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * ifcLoader.cleanUp();
+     * '''
+     */
+    cleanUp(): void;
+    private getAllGeometries;
+    private getMesh;
+    private getGeometry;
+    private autoSetWasm;
+}
+import * as WEBIFC from "web-ifc";
 import { AsyncEvent, Component, Disposable, Event } from "../../core";
 import { PropertiesStreamingSettings } from "./src";
 /**
@@ -1622,373 +1709,83 @@ export declare class IfcGeometryTiler extends Component implements Disposable {
     private streamGeometries;
     private registerGeometryData;
 }
-import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
+import * as WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
 /**
- * Configuration interface for the VertexPicker component.
+ * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
  */
-export interface VertexPickerConfig {
-    /**
-     * If true, only vertices will be picked, not the closest point on the face.
-     */
-    showOnlyVertex: boolean;
+export declare class IfcJsonExporter extends Component {
     /**
-     * The maximum distance for snapping to a vertex.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    snapDistance: number;
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
     /**
-     * The HTML element to use for previewing the picked vertex.
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
      */
-    previewElement: HTMLElement;
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+import { RelationsMap, ModelsRelationMap, InverseAttribute, IfcRelation } from "./src";
 /**
- * A class that provides functionality for picking vertices in a 3D scene.
+ * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
  */
-export declare class 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>;
+export declare class IfcRelationsIndexer extends Component implements Disposable {
     /**
-     * An event that is triggered when the picker is enabled or disabled
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    readonly onEnabled: Event<boolean>;
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * A reference to the Components instance associated with this VertexPicker.
+     * Event triggered when relations for a model have been indexed.
+     * This event provides the model's UUID and the relations map generated for that model.
+     *
+     * @property {string} modelID - The UUID of the model for which relations have been indexed.
+     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
+     * The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
      */
-    components: Components;
+    readonly onRelationsIndexed: Event<{
+        modelID: string;
+        relationsMap: RelationsMap;
+    }>;
     /**
-     * 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.
+     * Holds the relationship mappings for each model processed by the indexer.
+     * The structure is a map where each key is a model's UUID, and the value is another map.
+     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
+     * representing a specific relation type, and the value is an array of expressIDs of entities
+     * that are related through that relation type. This structure allows for efficient querying
+     * of entity relationships within a model.
      */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
+    readonly relationMaps: ModelsRelationMap;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    private _relToAttributesMap;
+    private _inverseAttributes;
+    private _ifcRels;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    private indexRelations;
+    getAttributeIndex(inverseAttribute: InverseAttribute): number | null;
     /**
-     * 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.
+     * Adds a relation map to the model's relations map.
      *
-     * @param value - The new enabled state.
-     */
-    set enabled(value: boolean);
-    /**
-     * Gets the current enabled state of the VertexPicker.
+     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
+     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
      *
-     * @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 { XMLParser } from "fast-xml-parser";
-import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core";
-import { BCFTopic, Topic, BCFTopicsConfigManager, BCFTopicsConfig } from "./src";
-import { Viewpoint } from "../../core/Viewpoints";
-/**
- * BCFTopics manages Building Collaboration Format (BCF) data the engine.
- * It provides functionality for importing, exporting, and manipulating BCF data.
- */
-export declare class BCFTopics extends Component implements Disposable, Configurable<BCFTopicsConfigManager, BCFTopicsConfig> {
-    static uuid: "de977976-e4f6-4e4f-a01a-204727839802";
-    enabled: boolean;
-    static xmlParser: XMLParser;
-    protected _defaultConfig: Required<BCFTopicsConfig>;
-    config: BCFTopicsConfigManager;
-    readonly list: DataMap<string, Topic>;
-    readonly onSetup: Event<unknown>;
-    isSetup: boolean;
-    setup(config?: Partial<BCFTopicsConfig>): void;
-    readonly onBCFImported: Event<Topic[]>;
-    /**
-     * Creates a new BCFTopic instance and adds it to the list.
-     *
-     * @param data - Optional partial BCFTopic object to initialize the new topic with.
-     * If not provided, default values will be used.
-     * @returns The newly created BCFTopic instance.
-     */
-    create(data?: Partial<BCFTopic>): Topic;
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Disposes of the BCFTopics component and triggers the onDisposed event.
-     *
-     * @remarks
-     * This method clears the list of topics and triggers the onDisposed event.
-     * It also resets the onDisposed event listener.
-     */
-    dispose(): void;
-    /**
-     * Retrieves the unique set of topic types used across all topics.
-     *
-     * @returns A Set containing the unique topic types.
-     */
-    get usedTypes(): Set<string>;
-    /**
-     * Retrieves the unique set of topic statuses used across all topics.
-     *
-     * @returns A Set containing the unique topic statuses.
-     */
-    get usedStatuses(): Set<string>;
-    /**
-     * Retrieves the unique set of topic priorities used across all topics.
-     *
-     * @returns A Set containing the unique topic priorities.
-     * Note: This method filters out any null or undefined priorities.
-     */
-    get usedPriorities(): Set<string | undefined>;
-    /**
-     * Retrieves the unique set of topic stages used across all topics.
-     *
-     * @returns A Set containing the unique topic stages.
-     * Note: This method filters out any null or undefined stages.
-     */
-    get usedStages(): Set<string | undefined>;
-    /**
-     * Retrieves the unique set of users associated with topics.
-     *
-     * @returns A Set containing the unique users.
-     * Note: This method collects users from the creation author, assigned to, modified author, and comment authors.
-     */
-    get usedUsers(): Set<string>;
-    /**
-     * Retrieves the unique set of labels used across all topics.
-     *
-     * @returns A Set containing the unique labels.
-     */
-    get usedLabels(): Set<string>;
-    /**
-     * Updates the set of extensions (types, statuses, priorities, labels, stages, users) based on the current topics.
-     * This method iterates through each topic in the list and adds its properties to the corresponding sets in the config.
-     */
-    updateExtensions(): void;
-    /**
-     * Updates the references to viewpoints in the topics.
-     * This function iterates through each topic and checks if the viewpoints exist in the viewpoints list.
-     * If a viewpoint does not exist, it is removed from the topic's viewpoints.
-     */
-    updateViewpointReferences(): void;
-    /**
-     * Exports the given topics to a BCF (Building Collaboration Format) zip file.
-     *
-     * @param topics - The topics to export. Defaults to all topics in the list.
-     * @returns A promise that resolves to a Blob containing the exported BCF zip file.
-     */
-    export(topics?: Iterable<Topic>): Promise<Blob>;
-    private serializeExtensions;
-    private processMarkupComment;
-    private getMarkupComments;
-    private getMarkupLabels;
-    private getMarkupViewpoints;
-    private getMarkupRelatedTopics;
-    /**
-     * Loads BCF (Building Collaboration Format) data into the engine.
-     *
-     * @param world - The default world where the viewpoints are going to be created.
-     * @param data - The BCF data to load.
-     *
-     * @returns A promise that resolves to an object containing the created viewpoints and topics.
-     *
-     * @throws An error if the BCF version is not supported.
-     */
-    load(data: Uint8Array, world: World): Promise<{
-        viewpoints: Viewpoint[];
-        topics: Topic[];
-    }>;
-}
-import * as FRAGS from "@thatopen/fragments";
-import { XMLParser } from "fast-xml-parser";
-import { Component, DataMap } from "../../core/Types";
-import { IDSCheckResult, IDSInfo, IDSSpecification, IfcVersion } from "./src";
-import { Components } from "../../core";
-/**
- * Component that manages Information Delivery Specification (IDS) data.
- * It provides functionality for importing, exporting, and manipulating IDS data.
- */
-export declare class IDSSpecifications extends Component {
-    static uuid: "9f0b9f78-9b2e-481a-b766-2fbfd01f342c";
-    enabled: boolean;
-    static xmlParser: XMLParser;
-    constructor(components: Components);
-    readonly list: DataMap<string, IDSSpecification>;
-    /**
-     * Retrieves a FragmentIdMap based on the given IDSCheckResult array.
-     * The map separates the IDs into two categories: pass and fail.
-     *
-     * @param model - The FragmentsGroup model from which to retrieve the fragment map.
-     * @param result - An array of IDSCheckResult objects, each representing a check result.
-     *
-     * @returns An object containing two properties:
-     * - 'pass': A FragmentIdMap that passed the checks.
-     * - 'fail': A FragmentIdMap that failed the checks.
-     */
-    getFragmentIdMap(model: FRAGS.FragmentsGroup, result: IDSCheckResult[]): {
-        pass: FRAGS.FragmentIdMap;
-        fail: FRAGS.FragmentIdMap;
-    };
-    /**
-     * Creates a new IDSSpecification instance and adds it to the list.
-     *
-     * @param name - The name of the IDSSpecification.
-     * @param ifcVersion - An array of IfcVersion values that the specification supports.
-     *
-     * @returns The newly created IDSSpecification instance.
-     */
-    create(name: string, ifcVersion: IfcVersion[], identifier?: string): IDSSpecification;
-    /**
-     * Parses and processes an XML string containing Information Delivery Specification (IDS) data.
-     * It creates IDSSpecification instances based on the parsed data and returns them in an array.
-     * Also, the instances are added to the list array.
-     *
-     * @param data - The XML string to parse.
-     *
-     * @returns An array of IDSSpecification instances created from the parsed data.
-     */
-    load(data: string): IDSSpecification[];
-    /**
-     * Exports the IDSSpecifications data into an XML string.
-     *
-     * @param info - The metadata information for the exported XML.
-     * @param specifications - An optional iterable of IDSSpecification instances to export.
-     * If not provided, all specifications in the list will be exported.
-     *
-     * @returns A string containing the exported IDSSpecifications data in XML format.
-     */
-    export(info: IDSInfo, specifications?: Iterable<IDSSpecification>): string;
-}
-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 { Disposable, Event, Component, Components } from "../../core";
-import { RelationsMap, ModelsRelationMap, InverseAttribute, IfcRelation } from "./src";
-/**
- * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
- */
-export declare class IfcRelationsIndexer extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Event triggered when relations for a model have been indexed.
-     * This event provides the model's UUID and the relations map generated for that model.
-     *
-     * @property {string} modelID - The UUID of the model for which relations have been indexed.
-     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
-     * The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
-     */
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
-    /**
-     * Holds the relationship mappings for each model processed by the indexer.
-     * The structure is a map where each key is a model's UUID, and the value is another map.
-     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
-     * representing a specific relation type, and the value is an array of expressIDs of entities
-     * that are related through that relation type. This structure allows for efficient querying
-     * of entity relationships within a model.
-     */
-    readonly relationMaps: ModelsRelationMap;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _relToAttributesMap;
-    private _inverseAttributes;
-    private _ifcRels;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    private indexRelations;
-    getAttributeIndex(inverseAttribute: InverseAttribute): number | null;
-    /**
-     * Adds a relation map to the model's relations map.
-     *
-     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
-     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
-     *
-     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
+     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
      */
     setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
     /**
@@ -2281,7 +2078,6 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
      */
     newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
         pset: WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
-        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties;
     }>;
     /**
      * Removes a Property Set (Pset) from the given model.
@@ -2425,110 +2221,119 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
     private registerChange;
     private newSingleProperty;
 }
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components } from "../../core";
+import { XMLParser } from "fast-xml-parser";
+import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core";
+import { BCFTopic, Topic, BCFTopicsConfigManager, BCFTopicsConfig } from "./src";
+import { Viewpoint } from "../../core/Viewpoints";
 /**
- * Represents an edge measurement result.
+ * BCFTopics manages Building Collaboration Format (BCF) data the engine.
+ * It provides functionality for importing, exporting, and manipulating BCF data.
  */
-export interface MeasureEdge {
+export declare class BCFTopics extends Component implements Disposable, Configurable<BCFTopicsConfigManager, BCFTopicsConfig> {
+    static uuid: "de977976-e4f6-4e4f-a01a-204727839802";
+    enabled: boolean;
+    static xmlParser: XMLParser;
+    protected _defaultConfig: Required<BCFTopicsConfig>;
+    config: BCFTopicsConfigManager;
+    readonly list: DataMap<string, Topic>;
+    readonly onSetup: Event<unknown>;
+    isSetup: boolean;
+    setup(config?: Partial<BCFTopicsConfig>): void;
+    readonly onBCFImported: Event<Topic[]>;
     /**
-     * The distance between the two points of the edge.
+     * Creates a new BCFTopic instance and adds it to the list.
+     *
+     * @param data - Optional partial BCFTopic object to initialize the new topic with.
+     * If not provided, default values will be used.
+     * @returns The newly created BCFTopic instance.
      */
-    distance: number;
+    create(data?: Partial<BCFTopic>): Topic;
+    readonly onDisposed: Event<unknown>;
     /**
-     * The two points that define the edge.
+     * Disposes of the BCFTopics component and triggers the onDisposed event.
+     *
+     * @remarks
+     * This method clears the list of topics and triggers the onDisposed event.
+     * It also resets the onDisposed event listener.
      */
-    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 {
+    dispose(): void;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Retrieves the unique set of topic types used across all topics.
+     *
+     * @returns A Set containing the unique topic types.
      */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    get usedTypes(): Set<string>;
     /**
-     * Utility method to calculate the distance from a point to a line segment.
+     * Retrieves the unique set of topic statuses used across all topics.
      *
-     * @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.
+     * @returns A Set containing the unique topic statuses.
      */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    get usedStatuses(): Set<string>;
     /**
-     * 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.
+     * Retrieves the unique set of topic priorities used across all topics.
      *
-     * @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.
+     * @returns A Set containing the unique topic priorities.
+     * Note: This method filters out any null or undefined priorities.
      */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
+    get usedPriorities(): Set<string | undefined>;
     /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
+     * Retrieves the unique set of topic stages used across all topics.
      *
-     * @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.
+     * @returns A Set containing the unique topic stages.
+     * Note: This method filters out any null or undefined stages.
      */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
+    get usedStages(): Set<string | undefined>;
     /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
+     * Retrieves the unique set of users associated with topics.
      *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
+     * @returns A Set containing the unique users.
+     * Note: This method collects users from the creation author, assigned to, modified author, and comment authors.
      */
-    round(vector: THREE.Vector3): void;
+    get usedUsers(): Set<string>;
     /**
-     * Calculates the volume of a set of fragments.
-     *
-     * @param frags - A map of fragment IDs to their corresponding item IDs.
-     * @returns The total volume of the fragments and the bounding sphere.
+     * Retrieves the unique set of labels used across all topics.
      *
-     * @remarks
-     * This method creates a set of instanced meshes from the given fragments and item IDs.
-     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
+     * @returns A Set containing the unique labels.
+     */
+    get usedLabels(): Set<string>;
+    /**
+     * Updates the set of extensions (types, statuses, priorities, labels, stages, users) based on the current topics.
+     * This method iterates through each topic in the list and adds its properties to the corresponding sets in the config.
+     */
+    updateExtensions(): void;
+    /**
+     * Updates the references to viewpoints in the topics.
+     * This function iterates through each topic and checks if the viewpoints exist in the viewpoints list.
+     * If a viewpoint does not exist, it is removed from the topic's viewpoints.
+     */
+    updateViewpointReferences(): void;
+    /**
+     * Exports the given topics to a BCF (Building Collaboration Format) zip file.
      *
-     * @throws Will throw an error if the geometry of the meshes is not indexed.
-     * @throws Will throw an error if the fragment manager is not available.
+     * @param topics - The topics to export. Defaults to all topics in the list.
+     * @returns A promise that resolves to a Blob containing the exported BCF zip file.
      */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    export(topics?: Iterable<Topic>): Promise<Blob>;
+    private serializeExtensions;
+    private processMarkupComment;
+    private getMarkupComments;
+    private getMarkupLabels;
+    private getMarkupViewpoints;
+    private getMarkupRelatedTopics;
     /**
-     * Calculates the total volume of a set of meshes.
+     * Loads BCF (Building Collaboration Format) data into the engine.
      *
-     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
-     * @returns The total volume of the meshes and the bounding sphere.
+     * @param world - The default world where the viewpoints are going to be created.
+     * @param data - The BCF data to load.
      *
-     * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
+     * @returns A promise that resolves to an object containing the created viewpoints and topics.
      *
+     * @throws An error if the BCF version is not supported.
      */
-    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
-    private getFaceData;
-    private getVolumeOfMesh;
-    private getSignedVolumeOfTriangle;
+    load(data: Uint8Array, world: World): Promise<{
+        viewpoints: Viewpoint[];
+        topics: Topic[];
+    }>;
 }
 import { Component, Components } from "../../core";
 import { IfcQueryGroup } from "./src/ifc-query-group";
@@ -2573,19 +2378,229 @@ export declare class IfcFinder extends Component {
     /**
      * Creates the {@link IfcQueryGroup} with the given ID.
      */
-    delete(id: string): void;
+    delete(id: string): void;
+    /**
+     * Deletes all {@link IfcQueryGroup} instances.
+     */
+    clear(): void;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { XMLParser } from "fast-xml-parser";
+import { Component, DataMap } from "../../core/Types";
+import { IDSCheckResult, IDSInfo, IDSSpecification, IfcVersion } from "./src";
+import { Components } from "../../core";
+/**
+ * Component that manages Information Delivery Specification (IDS) data.
+ * It provides functionality for importing, exporting, and manipulating IDS data.
+ */
+export declare class IDSSpecifications extends Component {
+    static uuid: "9f0b9f78-9b2e-481a-b766-2fbfd01f342c";
+    enabled: boolean;
+    static xmlParser: XMLParser;
+    constructor(components: Components);
+    readonly list: DataMap<string, IDSSpecification>;
+    /**
+     * Retrieves a FragmentIdMap based on the given IDSCheckResult array.
+     * The map separates the IDs into two categories: pass and fail.
+     *
+     * @param model - The FragmentsGroup model from which to retrieve the fragment map.
+     * @param result - An array of IDSCheckResult objects, each representing a check result.
+     *
+     * @returns An object containing two properties:
+     * - 'pass': A FragmentIdMap that passed the checks.
+     * - 'fail': A FragmentIdMap that failed the checks.
+     */
+    getFragmentIdMap(model: FRAGS.FragmentsGroup, result: IDSCheckResult[]): {
+        pass: FRAGS.FragmentIdMap;
+        fail: FRAGS.FragmentIdMap;
+    };
+    /**
+     * Creates a new IDSSpecification instance and adds it to the list.
+     *
+     * @param name - The name of the IDSSpecification.
+     * @param ifcVersion - An array of IfcVersion values that the specification supports.
+     *
+     * @returns The newly created IDSSpecification instance.
+     */
+    create(name: string, ifcVersion: IfcVersion[], identifier?: string): IDSSpecification;
+    /**
+     * Parses and processes an XML string containing Information Delivery Specification (IDS) data.
+     * It creates IDSSpecification instances based on the parsed data and returns them in an array.
+     * Also, the instances are added to the list array.
+     *
+     * @param data - The XML string to parse.
+     *
+     * @returns An array of IDSSpecification instances created from the parsed data.
+     */
+    load(data: string): IDSSpecification[];
+    /**
+     * Exports the IDSSpecifications data into an XML string.
+     *
+     * @param info - The metadata information for the exported XML.
+     * @param specifications - An optional iterable of IDSSpecification instances to export.
+     * If not provided, all specifications in the list will be exported.
+     *
+     * @returns A string containing the exported IDSSpecifications data in XML format.
+     */
+    export(info: IDSInfo, specifications?: Iterable<IDSSpecification>): string;
+}
+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 {
+    /**
+     * If true, only vertices will be picked, not the closest point on the face.
+     */
+    showOnlyVertex: boolean;
+    /**
+     * The maximum distance for snapping to a vertex.
+     */
+    snapDistance: number;
+    /**
+     * The HTML element to use for previewing the picked vertex.
+     */
+    previewElement: HTMLElement;
+}
+/**
+ * A class that provides functionality for picking vertices in a 3D scene.
+ */
+export declare class VertexPicker extends Component implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
+     */
+    readonly onVertexFound: Event<THREE.Vector3>;
+    /**
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
+     */
+    readonly onVertexLost: Event<THREE.Vector3>;
+    /**
+     * An event that is triggered when the picker is enabled or disabled
+     */
+    readonly onEnabled: Event<boolean>;
+    /**
+     * A reference to the Components instance associated with this VertexPicker.
+     */
+    components: Components;
+    /**
+     * A reference to the working plane used for vertex picking.
+     * This plane is used to determine which vertices are considered valid for picking.
+     * If this value is null, all vertices are considered valid.
+     */
+    workingPlane: THREE.Plane | null;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
+    /**
+     * Sets the enabled state of the VertexPicker.
+     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
+     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
+     *
+     * @param value - The new enabled state.
+     */
+    set enabled(value: boolean);
+    /**
+     * Gets the current enabled state of the VertexPicker.
+     *
+     * @returns The current enabled state.
+     */
+    get enabled(): boolean;
+    /**
+     * Sets the configuration for the VertexPicker component.
+     *
+     * @param value - A Partial object containing the configuration properties to update.
+     * The properties not provided in the value object will retain their current values.
+     *
+     * @example
+     * '''typescript
+     * vertexPicker.config = {
+     *   snapDistance: 0.5,
+     *   showOnlyVertex: true,
+     * };
+     * '''
+     */
+    set config(value: Partial<VertexPickerConfig>);
+    /**
+     * Gets the current configuration for the VertexPicker component.
+     *
+     * @returns A copy of the current VertexPickerConfig object.
+     *
+     * @example
+     * '''typescript
+     * const currentConfig = vertexPicker.config;
+     * console.log(currentConfig.snapDistance); // Output: 0.25
+     * '''
+     */
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
+     *
+     * @param world - The World instance to use for raycasting.
+     *
+     * @returns The current picked point, or null if no point is picked.
+     *
+     * @remarks
+     * This method checks if the VertexPicker is enabled. If not, it returns the current picked point.
+     * If enabled, it performs raycasting to find the closest intersecting object.
+     * It then determines the closest vertex or point on the face, based on the configuration settings.
+     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
+     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
+     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
+     */
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+import { BooleanSettingsControl } from "../../Types";
+import { Viewpoints } from "../index";
+import { Configurator } from "../../ConfigManager";
+/**
+ * Configuration interface for the Viewpoints general behavior.
+ */
+export interface ViewpointsConfig {
     /**
-     * Deletes all {@link IfcQueryGroup} instances.
+     * Indicates whether to overwrite the fragments colors when applying viewpoints.
+     * @remarks BCF Viewpoints comes with information to indicate the colors to be applied to components, if any.
+     * @default false
      */
-    clear(): void;
-}
-import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
+    overwriteColors: boolean;
 }
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
+type ViewpointsConfigType = {
+    overwriteColors: BooleanSettingsControl;
+};
+export declare class ViewpointsConfigManager extends Configurator<Viewpoints, ViewpointsConfigType> {
+    protected _config: ViewpointsConfigType;
+    get overwriteColors(): boolean;
+    set overwriteColors(value: boolean);
 }
+export {};
 import * as THREE from "three";
 import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
@@ -2619,65 +2634,6 @@ export declare class ClipperConfigManager extends Configurator<Clipper, ClipperC
     set size(value: number);
 }
 export {};
-import { BooleanSettingsControl } from "../../Types";
-import { Viewpoints } from "../index";
-import { Configurator } from "../../ConfigManager";
-/**
- * Configuration interface for the Viewpoints general behavior.
- */
-export interface ViewpointsConfig {
-    /**
-     * Indicates whether to overwrite the fragments colors when applying viewpoints.
-     * @remarks BCF Viewpoints comes with information to indicate the colors to be applied to components, if any.
-     * @default false
-     */
-    overwriteColors: boolean;
-}
-type ViewpointsConfigType = {
-    overwriteColors: BooleanSettingsControl;
-};
-export declare class ViewpointsConfigManager extends Configurator<Viewpoints, ViewpointsConfigType> {
-    protected _config: ViewpointsConfigType;
-    get overwriteColors(): boolean;
-    set overwriteColors(value: boolean);
-}
-export {};
-/**
- * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
- *
- * @remarks
- * This map is used to provide a mapping between IFC entity type numbers and their names.
- * It is useful for identifying and processing different types of IFC elements in a project.
- *
- */
-export declare const IfcElements: {
-    [key: number]: string;
-};
-import * as FRAGS from "@thatopen/fragments";
-export declare class IfcPropertiesUtils {
-    static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
-    static findItemByGuid(model: FRAGS.FragmentsGroup, guid: string): Promise<{
-        [attribute: string]: any;
-    } | null>;
-    static getRelationMap(model: FRAGS.FragmentsGroup, relationType: number, onElementsFound?: (relatingID: number, relatedIDs: number[]) => Promise<void>): Promise<{
-        [relatingID: number]: number[];
-    }>;
-    static getQsetQuantities(model: FRAGS.FragmentsGroup, expressID: number, onQuantityFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetProps(model: FRAGS.FragmentsGroup, expressID: number, onPropFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetRel(model: FRAGS.FragmentsGroup, psetID: number): Promise<number | null>;
-    static getQsetRel(model: FRAGS.FragmentsGroup, qsetID: number): Promise<number | null>;
-    static getEntityName(model: FRAGS.FragmentsGroup, entityID: number): Promise<{
-        key: string | null;
-        name: string | null;
-    }>;
-    static getQuantityValue(model: FRAGS.FragmentsGroup, quantityID: number): Promise<{
-        key: string | null;
-        value: number | null;
-    }>;
-    static isRel(expressID: number): boolean;
-    static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
-    static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
-}
 import * as WEBIFC from "web-ifc";
 /** Configuration of the IFC-fragment conversion. */
 export declare class IfcFragmentSettings {
@@ -2703,264 +2659,94 @@ export declare class IfcFragmentSettings {
     /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
     webIfc: WEBIFC.LoaderSettings;
     /**
-     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * If set to true, the path will be set to the default path of the WASM file.
-     * If set to false, the path must be provided manually in the 'wasm.path' property.
-     * Default value is true.
-     */
-    autoSetWasm: boolean;
-    /**
-     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
-     * If set to null, the default file location handler will be used.
-     *
-     * @param url - The URL of the file to locate.
-     * @returns The absolute path of the file.
-     */
-    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
-}
-/**
- * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
- */
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
-export declare const ifcCategoryCase: {
-    [upperCase: string]: string;
-};
-import * as FRAGS from "@thatopen/fragments";
-import * as WEBIFC from "web-ifc";
-export declare class SpatialIdsFinder {
-    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
-}
-import * as WEBIFC from "web-ifc";
-import { IfcItemsCategories } from "../../../ifc";
-export declare class SpatialStructure {
-    itemsByFloor: IfcItemsCategories;
-    private _units;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    cleanUp(): void;
-}
-/**
- * A Set of unique numbers representing different types of IFC geometries.
- */
-export declare const GeometryTypes: Set<number>;
-import * as THREE from "three";
-import { Disposable, Event } from "../../Types";
-/**
- * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
- */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
-    /**
-     * The real position of the mouse of the Three.js canvas.
-     */
-    get position(): THREE.Vector2;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private getDataObject;
-    private setupEvents;
-}
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
-/**
- * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
- */
-export declare class SimpleRaycaster implements Disposable {
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** The components instance to which this Raycaster belongs. */
-    components: Components;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The position of the mouse in the screen. */
-    readonly mouse: Mouse;
-    /**
-     * A reference to the Three.js Raycaster instance.
-     * This is used for raycasting operations.
-     */
-    readonly three: THREE.Raycaster;
-    /**
-     * A reference to the world instance to which this Raycaster belongs.
-     * This is used to access the camera and meshes.
-     */
-    world: World;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Throws a ray from the camera to the mouse or touch event point and returns
-     * the first item found. This also takes into account the clipping planes
-     * used by the renderer.
-     *
-     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
-     * to query. If not provided, it will query all the meshes stored in
-     * {@link Components.meshes}.
-     */
-    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
-    /**
-     * Casts a ray from a given origin in a given direction and returns the first item found.
-     * This method also takes into account the clipping planes used by the renderer.
-     *
-     * @param origin - The origin of the ray.
-     * @param direction - The direction of the ray.
-     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
-     * @returns The first intersection found or 'null' if no intersection was found.
-     */
-    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
-    private intersect;
-    private filterClippingPlanes;
-}
-import * as THREE from "three";
-import { CullerRenderer } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-/**
- * A renderer to hide/show meshes depending on their visibility from the user's point of view.
- */
-export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
-    /**
-     * Event triggered when the visibility of meshes is updated.
-     * Contains two sets: seen and unseen.
-     */
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
-    }>;
-    /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
-     */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    /**
-     * @deprecated use config.threshold instead.
-     */
-    get threshold(): number;
-    /**
-     * @deprecated use config.threshold instead.
-     */
-    set threshold(value: number);
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
-     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     */
-    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.
+     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * If set to true, the path will be set to the default path of the WASM file.
+     * If set to false, the path must be provided manually in the 'wasm.path' property.
+     * Default value is true.
      */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    autoSetWasm: boolean;
     /**
-     * Updates the given instanced meshes inside the culler. You should use this if you change the count property, e.g. when changing the visibility of fragments.
-     *
-     * @param meshes - The meshes to update.
+     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
+     * If set to null, the default file location handler will be used.
      *
-     * @returns {void}
+     * @param url - The URL of the file to locate.
+     * @returns The absolute path of the file.
      */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+import * as FRAGS from "@thatopen/fragments";
+import * as WEBIFC from "web-ifc";
+export declare class SpatialIdsFinder {
+    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+}
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
+}
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
 }
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { AsyncEvent, Configurable, Event, World } from "../../Types";
-import { CullerRendererConfig, CullerRendererConfigManager } from "./culler-renderer-config";
 /**
- * A base renderer to determine visibility on screen.
+ * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
+ *
+ * @remarks
+ * This map is used to provide a mapping between IFC entity type numbers and their names.
+ * It is useful for identifying and processing different types of IFC elements in a project.
+ *
  */
-export declare class CullerRenderer implements Configurable<CullerRendererConfigManager, CullerRendererConfig> {
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
-     */
-    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
-    /**
-     * Whether this renderer is active or not. If not, it won't render anything.
-     */
-    enabled: boolean;
-    /**
-     * 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.
-     */
-    needsUpdate: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /** The render target used to render the visibility scene. */
-    renderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
-    /**
-     * The size of the buffer where the result of the visibility check is stored.
-     */
-    bufferSize: number;
-    /**
-     * The buffer when the result of the visibility check is stored.
-     */
-    buffer: Uint8Array;
-    /**
-     * Flag to indicate if the renderer shouldn't update the visibility.
-     */
-    preventUpdate: boolean;
-    /** {@link Configurable.config} */
-    config: CullerRendererConfigManager;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /** 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 _defaultConfig: CullerRendererConfig;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _availableColor;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
-     */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    setup(config?: Partial<CullerRendererConfig>): void;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
+export declare const IfcElements: {
+    [key: number]: string;
+};
+/**
+ * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
+ */
+export declare const IfcCategoryMap: {
+    [key: number]: string;
+};
+import * as FRAGS from "@thatopen/fragments";
+export declare class IfcPropertiesUtils {
+    static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
+    static findItemByGuid(model: FRAGS.FragmentsGroup, guid: string): Promise<{
+        [attribute: string]: any;
+    } | null>;
+    static getRelationMap(model: FRAGS.FragmentsGroup, relationType: number, onElementsFound?: (relatingID: number, relatedIDs: number[]) => Promise<void>): Promise<{
+        [relatingID: number]: number[];
+    }>;
+    static getQsetQuantities(model: FRAGS.FragmentsGroup, expressID: number, onQuantityFound?: (expressID: number) => void): Promise<number[] | null>;
+    static getPsetProps(model: FRAGS.FragmentsGroup, expressID: number, onPropFound?: (expressID: number) => void): Promise<number[] | null>;
+    static getPsetRel(model: FRAGS.FragmentsGroup, psetID: number): Promise<number | null>;
+    static getQsetRel(model: FRAGS.FragmentsGroup, qsetID: number): Promise<number | null>;
+    static getEntityName(model: FRAGS.FragmentsGroup, entityID: number): Promise<{
+        key: string | null;
+        name: string | null;
+    }>;
+    static getQuantityValue(model: FRAGS.FragmentsGroup, quantityID: number): Promise<{
+        key: string | null;
+        value: number | null;
+    }>;
+    static isRel(expressID: number): boolean;
+    static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
+    static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
 }
-import { InverseAttribute } from "./types";
-export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856 | 2857406711 | 2565941209 | 2495723537 | 3268803585 | 982818633, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;
+export declare const ifcCategoryCase: {
+    [upperCase: string]: string;
+};
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createPropertyFacets: (components: Components, elements: any) => IDSFacet[];
+/**
+ * A Set of unique numbers representing different types of IFC geometries.
+ */
+export declare const GeometryTypes: Set<number>;
 import * as FRAGS from "@thatopen/fragments";
 import { IfcFinderQuery } from "./ifc-finder-query";
 import { Components } from "../../../core";
@@ -3030,9 +2816,6 @@ export declare class IfcQueryGroup {
      */
     update(modelID: string, file: File): Promise<void>;
 }
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "../facets";
-export declare const createPropertyFacets: (components: Components, elements: any) => IDSFacet[];
 /**
  * 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.
  */
@@ -3061,7 +2844,11 @@ export declare class Event<T> {
     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 { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856 | 2857406711 | 2565941209 | 2495723537 | 3268803585 | 982818633, {
+    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.
  */
@@ -3210,34 +2997,6 @@ export declare abstract class Component extends Base {
      */
     abstract enabled: boolean;
 }
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { BaseWorldItem } from "./base-world-item";
-import { CameraControllable } from "./interfaces";
-/**
- * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
- */
-export declare abstract class BaseCamera extends BaseWorldItem {
-    /**
-     * Whether the camera is enabled or not.
-     */
-    abstract enabled: boolean;
-    /**
-     * The Three.js camera instance.
-     */
-    abstract three: THREE.Camera;
-    /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
-     */
-    abstract controls?: CameraControls;
-    /**
-     * Checks whether the instance is {@link CameraControllable}.
-     *
-     * @returns True if the instance is controllable, false otherwise.
-     */
-    hasCameraControls: () => this is CameraControllable;
-}
 import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
 import { Components } from "../../Components";
 /**
@@ -3254,115 +3013,59 @@ export declare abstract class Base {
     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, any>;
-}
-import { Base } from "./base";
-import { World } from "./world";
-import { Event } from "./event";
-import { Components } from "../../Components";
-/**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
- */
-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 { Disposable } from "./interfaces";
-import { Event } from "./event";
-import { Components } from "../../Components";
-import { BaseWorldItem } from "./base-world-item";
-/**
- * Abstract class representing a base scene in the application. All scenes should use this class as a base.
- */
-export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Abstract property representing the three.js object associated with this scene.
-     * It should be implemented by subclasses.
-     */
-    abstract three: THREE.Object3D;
-    /** The set of directional lights managed by this scene component. */
-    directionalLights: Map<string, THREE.DirectionalLight>;
-    /** The set of ambient lights managed by this scene component. */
-    ambientLights: Map<string, THREE.AmbientLight>;
-    protected constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    deleteAllLights(): void;
+    /** Whether is component is {@link Configurable}. */
+    isConfigurable: () => this is Configurable<any, any>;
 }
+import { Base } from "./base";
+import { World } from "./world";
 import { Event } from "./event";
+import { Components } from "../../Components";
 /**
- * A class that extends the built-in Set class and provides additional functionality.
- * It triggers events when items are added, deleted, or the set is cleared.
- *
- * @template T - The type of elements in the set.
+ * One of the elements that make a world. It can be either a scene, a camera or a renderer.
  */
-export declare class DataSet<T> extends Set<T> {
-    /**
-     * An event that is triggered when a new item is added to the set.
-     */
-    readonly onItemAdded: Event<T>;
-    /**
-     * An event that is triggered when an item is deleted from the set.
-     */
-    readonly onItemDeleted: Event<unknown>;
+export declare abstract class BaseWorldItem extends Base {
+    readonly worlds: Map<string, World>;
     /**
-     * An event that is triggered when the set is cleared.
+     * 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 onCleared: Event<unknown>;
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
+    }>;
     /**
-     * Constructs a new instance of the DataSet class.
-     *
-     * @param iterable - An optional iterable object to initialize the set with.
+     * The current world this item is associated with. It can be null if no world is currently active.
      */
-    constructor(iterable?: Iterable<T> | null);
+    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 {
     /**
-     * Clears the set and triggers the onCleared event.
+     * Whether the camera is enabled or not.
      */
-    clear(): void;
+    abstract enabled: boolean;
     /**
-     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
-     *
-     * @param value - The value to add to the set.
-     * @returns - The set instance.
+     * The Three.js camera instance.
      */
-    add(...value: T[]): this;
+    abstract three: THREE.Camera;
     /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
-     *
-     * @param value - The value to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
+     * Optional CameraControls instance for controlling the camera.
+     * This property is only available if the camera is controllable.
      */
-    guard: (value: T) => boolean;
+    abstract controls?: CameraControls;
     /**
-     * Deletes a value from the set and triggers the onItemDeleted event.
+     * Checks whether the instance is {@link CameraControllable}.
      *
-     * @param value - The value to delete from the set.
-     * @returns - True if the value was successfully deleted, false otherwise.
-     */
-    delete(value: T): boolean;
-    /**
-     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
+     * @returns True if the instance is controllable, false otherwise.
      */
-    dispose(): void;
+    hasCameraControls: () => this is CameraControllable;
 }
 import * as THREE from "three";
 import { Vector2 } from "three";
@@ -3430,6 +3133,31 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
     setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }
 import * as THREE from "three";
+import { Disposable } from "./interfaces";
+import { Event } from "./event";
+import { Components } from "../../Components";
+import { BaseWorldItem } from "./base-world-item";
+/**
+ * Abstract class representing a base scene in the application. All scenes should use this class as a base.
+ */
+export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Abstract property representing the three.js object associated with this scene.
+     * It should be implemented by subclasses.
+     */
+    abstract three: THREE.Object3D;
+    /** The set of directional lights managed by this scene component. */
+    directionalLights: Map<string, THREE.DirectionalLight>;
+    /** The set of ambient lights managed by this scene component. */
+    ambientLights: Map<string, THREE.AmbientLight>;
+    protected constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    deleteAllLights(): void;
+}
+import * as THREE from "three";
 import { BaseScene } from "./base-scene";
 import { BaseCamera } from "./base-camera";
 import { BaseRenderer } from "./base-renderer";
@@ -3463,18 +3191,64 @@ export interface World extends Disposable, Updateable {
      */
     isDisposing: boolean;
 }
-import { Component } from "./component";
-export type ComponentUIElement = {
-    name: string;
-    componentID: string;
-    attributes: {
-        [name: string]: string;
-    };
-    get: () => HTMLElement;
-};
-export declare abstract class ComponentWithUI extends Component {
-    abstract name: string;
-    abstract getUI(): ComponentUIElement[];
+import { Event } from "./event";
+/**
+ * A class that extends the built-in Set class and provides additional functionality.
+ * It triggers events when items are added, deleted, or the set is cleared.
+ *
+ * @template T - The type of elements in the set.
+ */
+export declare class DataSet<T> extends Set<T> {
+    /**
+     * An event that is triggered when a new item is added to the set.
+     */
+    readonly onItemAdded: Event<T>;
+    /**
+     * An event that is triggered when an item is deleted from the set.
+     */
+    readonly onItemDeleted: Event<unknown>;
+    /**
+     * An event that is triggered when the set is cleared.
+     */
+    readonly onCleared: Event<unknown>;
+    /**
+     * Constructs a new instance of the DataSet class.
+     *
+     * @param iterable - An optional iterable object to initialize the set with.
+     */
+    constructor(iterable?: Iterable<T> | null);
+    /**
+     * Clears the set and triggers the onCleared event.
+     */
+    clear(): void;
+    /**
+     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
+     *
+     * @param value - The value to add to the set.
+     * @returns - The set instance.
+     */
+    add(...value: T[]): this;
+    /**
+     * A function that acts as a guard for adding items to the set.
+     * It determines whether a given value should be allowed to be added to the set.
+     *
+     * @param value - The value to be checked against the guard.
+     * @returns A boolean indicating whether the value should be allowed to be added to the set.
+     *          By default, this function always returns true, allowing all values to be added.
+     *          You can override this behavior by providing a custom implementation.
+     */
+    guard: (value: T) => boolean;
+    /**
+     * Deletes a value from the set and triggers the onItemDeleted event.
+     *
+     * @param value - The value to delete from the set.
+     * @returns - True if the value was successfully deleted, false otherwise.
+     */
+    delete(value: T): boolean;
+    /**
+     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
+     */
+    dispose(): void;
 }
 import { Event } from "./event";
 /**
@@ -3547,6 +3321,19 @@ export declare class DataMap<K, V> extends Map<K, V> {
      */
     dispose(): void;
 }
+import { Component } from "./component";
+export type ComponentUIElement = {
+    name: string;
+    componentID: string;
+    attributes: {
+        [name: string]: string;
+    };
+    get: () => HTMLElement;
+};
+export declare abstract class ComponentWithUI extends Component {
+    abstract name: string;
+    abstract getUI(): ComponentUIElement[];
+}
 import * as THREE from "three";
 export interface BooleanSettingsControl {
     type: "Boolean";
@@ -3590,29 +3377,143 @@ export interface ControlsSchema {
     [name: string]: ControlEntry | ControlsSchema;
 }
 import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
+import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
 import { Components } from "../../Components";
-import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
+import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
 /**
- * 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<SimpleSceneConfigManager, SimpleSceneConfig> {
+export declare class SimpleGrid implements Hideable, Disposable, Configurable<SimpleGridConfigManager, SimpleGridConfig> {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /** {@link Configurable.onSetup} */
     readonly onSetup: Event<unknown>;
     /** {@link Configurable.isSetup} */
     isSetup: boolean;
+    /** The world instance to which this Raycaster belongs. */
+    world: World;
+    /** The components instance to which this grid belongs. */
+    components: Components;
+    /** {@link Configurable.config} */
+    config: SimpleGridConfigManager;
+    protected _defaultConfig: SimpleGridConfig;
+    /** {@link Hideable.visible} */
+    get visible(): boolean;
+    /** {@link Hideable.visible} */
+    set visible(visible: boolean);
+    /** The material of the grid. */
+    get material(): THREE.ShaderMaterial;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    get fade(): boolean;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    set fade(active: boolean);
+    /** The Three.js mesh that contains the infinite grid. */
+    readonly three: THREE.Mesh;
+    private _fade;
+    constructor(components: Components, world: World);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleGridConfig>): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private setupEvents;
+    private updateZoom;
+}
+import * as THREE from "three";
+import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+import { SimpleGrid } from "./simple-grid";
+type SimpleGridConfigType = {
+    visible: BooleanSettingsControl;
+    color: ColorSettingsControl;
+    primarySize: NumberSettingControl;
+    secondarySize: NumberSettingControl;
+    distance: NumberSettingControl;
+};
+/**
+ * Configuration interface for the {@link SimpleGrid}.
+ */
+export interface SimpleGridConfig {
+    /**
+     * Whether the grid is visible or not.
+     */
+    visible: boolean;
+    /**
+     * The color of the grid lines.
+     */
+    color: THREE.Color;
+    /**
+     * The size of the primary grid lines.
+     */
+    primarySize: number;
     /**
-     * The underlying Three.js scene object.
-     * It is used to define the 3D space containing objects, lights, and cameras.
+     * The size of the secondary grid lines.
      */
-    three: THREE.Scene;
-    /** {@link Configurable.config} */
-    config: SimpleSceneConfigManager;
-    protected _defaultConfig: SimpleSceneConfig;
-    constructor(components: Components);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): void;
-    dispose(): void;
+    secondarySize: number;
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
+    distance: number;
+}
+export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
+    protected _config: SimpleGridConfigType;
+    /**
+     * Whether the grid is visible or not.
+     */
+    get visible(): boolean;
+    /**
+     * Whether the grid is visible or not.
+     */
+    set visible(value: boolean);
+    /**
+     * The color of the grid lines.
+     */
+    get color(): THREE.Color;
+    /**
+     * The color of the grid lines.
+     */
+    set color(value: THREE.Color);
+    /**
+     * The size of the primary grid lines.
+     */
+    get primarySize(): number;
+    /**
+     * The size of the primary grid lines.
+     */
+    set primarySize(value: number);
+    /**
+     * The size of the secondary grid lines.
+     */
+    get secondarySize(): number;
+    /**
+     * The size of the secondary grid lines.
+     */
+    set secondarySize(value: number);
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
+    get distance(): number;
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
+    set distance(value: number);
+}
+export {};
+import { ControlsSchema, ControlEntry } from "../../Types";
+import { Components } from "../../Components";
+export declare abstract class Configurator<T, U extends ControlsSchema> {
+    protected abstract _config: U;
+    protected _component: T;
+    name: string;
+    uuid: string;
+    get controls(): U;
+    constructor(component: T, components: Components, name: string, uuid?: string);
+    copyEntry(controlEntry: ControlEntry): ControlEntry;
 }
 import * as THREE from "three";
 import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
@@ -3694,6 +3595,31 @@ export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends Base
     dispose(disposeResources?: boolean): void;
 }
 import * as THREE from "three";
+import { BaseScene, Configurable, Event } from "../../Types";
+import { Components } from "../../Components";
+import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
+/**
+ * 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<SimpleSceneConfigManager, SimpleSceneConfig> {
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    /**
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
+     */
+    three: THREE.Scene;
+    /** {@link Configurable.config} */
+    config: SimpleSceneConfigManager;
+    protected _defaultConfig: SimpleSceneConfig;
+    constructor(components: Components);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleSceneConfig>): void;
+    dispose(): void;
+}
+import * as THREE from "three";
 import { BaseRenderer, Event } from "../../Types";
 import { Components } from "../../Components";
 /**
@@ -3776,349 +3702,234 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
      * The object that controls the camera. An instance of
      * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
      * Transforming the camera directly will have no effect: you need to use this
-     * object to move, rotate, look at objects, etc.
-     */
-    get controls(): CameraControls;
-    /**
-     * Getter for the enabled state of the camera controls.
-     * If the current world is null, it returns false.
-     * Otherwise, it returns the enabled state of the camera controls.
-     *
-     * @returns {boolean} The enabled state of the camera controls.
-     */
-    get enabled(): boolean;
-    /**
-     * Setter for the enabled state of the camera controls.
-     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
-     *
-     * @param {boolean} enabled - The new enabled state of the camera controls.
-     */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
-    /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
-     */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
-}
-import * as THREE from "three";
-import { SimpleScene } from "./simple-scene";
-import { ColorSettingsControl, NumberSettingControl, Vector3SettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-type SimpleSceneConfigType = {
-    backgroundColor: ColorSettingsControl;
-    ambientLight: {
-        color: ColorSettingsControl;
-        intensity: NumberSettingControl;
-    };
-    directionalLight: {
-        color: ColorSettingsControl;
-        intensity: NumberSettingControl;
-        position: Vector3SettingControl;
-    };
-};
-declare class DirectionalLightConfig {
-    private _list;
-    private _scene;
-    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get intensity(): number;
-    set intensity(value: number);
-    get position(): THREE.Vector3;
-    set position(value: THREE.Vector3);
-}
-declare class AmbientLightConfig {
-    private _list;
-    private _scene;
-    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get intensity(): number;
-    set intensity(value: number);
-}
-/**
- * Configuration interface for the {@link SimpleScene}.
- */
-export interface SimpleSceneConfig {
-    backgroundColor: THREE.Color;
-    directionalLight: {
-        color: THREE.Color;
-        intensity: number;
-        position: THREE.Vector3;
-    };
-    ambientLight: {
-        color: THREE.Color;
-        intensity: number;
-    };
-}
-export declare class SimpleSceneConfigManager extends Configurator<SimpleScene, SimpleSceneConfigType> {
-    protected _config: SimpleSceneConfigType;
-    ambientLight: AmbientLightConfig;
-    directionalLight: DirectionalLightConfig;
-    get backgroundColor(): THREE.Color;
-    set backgroundColor(value: THREE.Color);
-}
-export {};
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
- */
-export declare class OrbitMode implements NavigationMode {
-    camera: OrthoPerspectiveCamera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Orbit";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private activateOrbitControls;
-}
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
- */
-export declare class FirstPersonMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "FirstPerson";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private setupFirstPersonCamera;
-}
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
- */
-export declare class PlanMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Plan";
-    private mouseAction1?;
-    private mouseAction2?;
-    private mouseInitialized;
-    private readonly defaultAzimuthSpeed;
-    private readonly defaultPolarSpeed;
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-}
-import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
- */
-export declare class ProjectionManager {
-    /**
-     * Event that fires when the {@link CameraProjection} changes.
-     */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
-    /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
+     * object to move, rotate, look at objects, etc.
      */
-    current: CameraProjection;
+    get controls(): CameraControls;
     /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     * 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.
      */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    constructor(camera: OrthoPerspectiveCamera);
+    get enabled(): boolean;
     /**
-     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     * 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 projection - the new projection to set. If it is the current projection,
-     * it will have no effect.
+     * @param {boolean} enabled - The new enabled state of the camera controls.
      */
-    set(projection: CameraProjection): Promise<void>;
+    set enabled(enabled: boolean);
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(_delta: number): void;
     /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
      */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
-}
-/**
- * The projection system of the camera.
- */
-export type CameraProjection = "Perspective" | "Orthographic";
-/**
- * The extensible list of supported navigation modes.
- */
-export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
-/**
- * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
- */
-export interface NavigationMode {
-    /** The unique ID of this navigation mode. */
-    id: NavModeID;
-    /**
-     * Enable or disable this navigation mode.
-     * When a new navigation mode is enabled, the previous navigation mode
-     * must be disabled.
-     *
-     * @param active - whether to enable or disable this mode.
-     * @param options - any additional data required to enable or disable it.
-     * */
-    set: (active: boolean, options?: any) => void;
-    /** Whether this navigation mode is active or not. */
-    enabled: boolean;
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
 }
 import * as THREE from "three";
-import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-import { SimpleGrid } from "./simple-grid";
-type SimpleGridConfigType = {
-    visible: BooleanSettingsControl;
-    color: ColorSettingsControl;
-    primarySize: NumberSettingControl;
-    secondarySize: NumberSettingControl;
-    distance: NumberSettingControl;
-};
+import { Components } from "../../Components";
+import { AsyncEvent, Configurable, Event, World } from "../../Types";
+import { CullerRendererConfig, CullerRendererConfigManager } from "./culler-renderer-config";
 /**
- * Configuration interface for the {@link SimpleGrid}.
+ * A base renderer to determine visibility on screen.
  */
-export interface SimpleGridConfig {
-    /**
-     * Whether the grid is visible or not.
-     */
-    visible: boolean;
+export declare class CullerRenderer implements Configurable<CullerRendererConfigManager, CullerRendererConfig> {
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * The color of the grid lines.
+     * 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.
      */
-    color: THREE.Color;
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
     /**
-     * The size of the primary grid lines.
+     * Whether this renderer is active or not. If not, it won't render anything.
      */
-    primarySize: number;
+    enabled: boolean;
     /**
-     * The size of the secondary grid lines.
+     * 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.
      */
-    secondarySize: number;
+    needsUpdate: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /** The render target used to render the visibility scene. */
+    renderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
     /**
-     * The distance at which the grid lines start to fade away.
+     * The size of the buffer where the result of the visibility check is stored.
      */
-    distance: number;
-}
-export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
-    protected _config: SimpleGridConfigType;
+    bufferSize: number;
     /**
-     * Whether the grid is visible or not.
+     * The buffer when the result of the visibility check is stored.
      */
-    get visible(): boolean;
+    buffer: Uint8Array;
     /**
-     * Whether the grid is visible or not.
+     * Flag to indicate if the renderer shouldn't update the visibility.
      */
-    set visible(value: boolean);
+    preventUpdate: boolean;
+    /** {@link Configurable.config} */
+    config: CullerRendererConfigManager;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    /** 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 _defaultConfig: CullerRendererConfig;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _availableColor;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * The color of the grid lines.
+     * 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.
      */
-    get color(): THREE.Color;
+    updateVisibility: (force?: boolean) => Promise<void>;
+    setup(config?: Partial<CullerRendererConfig>): void;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
+}
+import * as THREE from "three";
+import { CullerRenderer } from "./culler-renderer";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+/**
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
+ */
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
-     * The color of the grid lines.
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
      */
-    set color(value: THREE.Color);
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
     /**
-     * The size of the primary grid lines.
+     * Map of color code to THREE.InstancedMesh.
+     * Used to keep track of color-coded meshes.
      */
-    get primarySize(): number;
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /**
-     * The size of the primary grid lines.
+     * @deprecated use config.threshold instead.
      */
-    set primarySize(value: number);
+    get threshold(): number;
     /**
-     * The size of the secondary grid lines.
+     * @deprecated use config.threshold instead.
      */
-    get secondarySize(): number;
+    set threshold(value: number);
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * The size of the secondary grid lines.
+     * 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.
      */
-    set secondarySize(value: number);
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     /**
-     * The distance at which the grid lines start to fade away.
+     * 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.
      */
-    get distance(): number;
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     /**
-     * The distance at which the grid lines start to fade away.
+     * Updates the given instanced meshes inside the culler. You should use this if you change the count property, e.g. when changing the visibility of fragments.
+     *
+     * @param meshes - The meshes to update.
+     *
+     * @returns {void}
      */
-    set distance(value: number);
+    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
 }
-export {};
 import * as THREE from "three";
-import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
-import { Components } from "../../Components";
-import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
+import { SimpleScene } from "./simple-scene";
+import { ColorSettingsControl, NumberSettingControl, Vector3SettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+type SimpleSceneConfigType = {
+    backgroundColor: ColorSettingsControl;
+    ambientLight: {
+        color: ColorSettingsControl;
+        intensity: NumberSettingControl;
+    };
+    directionalLight: {
+        color: ColorSettingsControl;
+        intensity: NumberSettingControl;
+        position: Vector3SettingControl;
+    };
+};
+declare class DirectionalLightConfig {
+    private _list;
+    private _scene;
+    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get intensity(): number;
+    set intensity(value: number);
+    get position(): THREE.Vector3;
+    set position(value: THREE.Vector3);
+}
+declare class AmbientLightConfig {
+    private _list;
+    private _scene;
+    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get intensity(): number;
+    set intensity(value: number);
+}
 /**
- * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ * Configuration interface for the {@link SimpleScene}.
  */
-export declare class SimpleGrid implements Hideable, Disposable, Configurable<SimpleGridConfigManager, SimpleGridConfig> {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /** The world instance to which this Raycaster belongs. */
-    world: World;
-    /** The components instance to which this grid belongs. */
-    components: Components;
-    /** {@link Configurable.config} */
-    config: SimpleGridConfigManager;
-    protected _defaultConfig: SimpleGridConfig;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    get fade(): boolean;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    set fade(active: boolean);
-    /** The Three.js mesh that contains the infinite grid. */
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleGridConfig>): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
+export interface SimpleSceneConfig {
+    backgroundColor: THREE.Color;
+    directionalLight: {
+        color: THREE.Color;
+        intensity: number;
+        position: THREE.Vector3;
+    };
+    ambientLight: {
+        color: THREE.Color;
+        intensity: number;
+    };
+}
+export declare class SimpleSceneConfigManager extends Configurator<SimpleScene, SimpleSceneConfigType> {
+    protected _config: SimpleSceneConfigType;
+    ambientLight: AmbientLightConfig;
+    directionalLight: DirectionalLightConfig;
+    get backgroundColor(): THREE.Color;
+    set backgroundColor(value: THREE.Color);
 }
+export {};
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable, Configurable } from "../../Types";
 import { MiniMapConfig, MiniMapConfigManager } from "./mini-map-config";
@@ -4219,17 +4030,6 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable, Conf
     setup(config?: Partial<MiniMapConfig>): void;
     private updatePlanes;
 }
-import { ControlsSchema, ControlEntry } from "../../Types";
-import { Components } from "../../Components";
-export declare abstract class Configurator<T, U extends ControlsSchema> {
-    protected abstract _config: U;
-    protected _component: T;
-    name: string;
-    uuid: string;
-    get controls(): U;
-    constructor(component: T, components: Components, name: string, uuid?: string);
-    copyEntry(controlEntry: ControlEntry): ControlEntry;
-}
 import * as THREE from "three";
 import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
@@ -4303,45 +4103,311 @@ export declare class MiniMapConfigManager extends Configurator<MiniMap, MiniMapC
     /**
      * The zoom of the camera in the minimap.
      */
-    set zoom(value: number);
+    set zoom(value: number);
+    /**
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     */
+    get frontOffset(): number;
+    /**
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     */
+    set frontOffset(value: number);
+    /**
+     * The horizontal dimension of the minimap.
+     */
+    get sizeX(): number;
+    /**
+     * The horizontal dimension of the minimap.
+     */
+    set sizeX(value: number);
+    /**
+     * The vertical dimension of the minimap.
+     */
+    get sizeY(): number;
+    /**
+     * The vertical dimension of the minimap.
+     */
+    set sizeY(value: number);
+    /**
+     * The color of the background of the minimap.
+     */
+    get backgroundColor(): THREE.Color;
+    /**
+     * The color of the background of the minimap.
+     */
+    set backgroundColor(value: THREE.Color);
+}
+export {};
+import * as THREE from "three";
+import { Event, World } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * A base renderer to determine visibility on screen.
+ */
+export declare class DistanceRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * Fires after making the visibility check to the meshes. It lists the
+     * meshes that are currently visible, and the ones that were visible
+     * just before but not anymore.
+     */
+    readonly onDistanceComputed: Event<number>;
+    /**
+     * Objects that won't be taken into account in the distance check.
+     */
+    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
+    /**
+     * Whether this renderer is active or not. If not, it won't render anything.
+     */
+    enabled: boolean;
+    /**
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
+     */
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /**
+     * The scene where the distance is computed.
+     */
+    scene: THREE.Scene;
+    /**
+     * The camera used to compute the distance.
+     */
+    camera: THREE.OrthographicCamera;
+    /**
+     * The material used to compute the distance.
+     */
+    depthMaterial: THREE.ShaderMaterial;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected readonly worker: Worker;
+    private _width;
+    private _height;
+    private readonly _postQuad;
+    private readonly tempRT;
+    private readonly resultRT;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    compute: () => Promise<void>;
+    private handleWorkerMessage;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
+ */
+export declare class OrbitMode implements NavigationMode {
+    camera: OrthoPerspectiveCamera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
+ */
+export declare class FirstPersonMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "FirstPerson";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
+ */
+export declare class PlanMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Plan";
+    private mouseAction1?;
+    private mouseAction2?;
+    private mouseInitialized;
+    private readonly defaultAzimuthSpeed;
+    private readonly defaultPolarSpeed;
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+}
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
+    /**
+     * Event that fires when the {@link CameraProjection} changes.
+     */
+    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+    /**
+     * Current projection mode of the camera.
+     * Default is "Perspective".
+     */
+    current: CameraProjection;
+    /**
+     * The camera controlled by this ProjectionManager.
+     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     */
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    private _component;
+    private _previousDistance;
+    constructor(camera: OrthoPerspectiveCamera);
     /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     * 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.
      */
-    get frontOffset(): number;
+    set(projection: CameraProjection): Promise<void>;
     /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
      */
-    set frontOffset(value: number);
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getPerspectiveDims;
+    private setupOrthoCamera;
+    private getDistance;
+    private setPerspectiveCamera;
+}
+/**
+ * The projection system of the camera.
+ */
+export type CameraProjection = "Perspective" | "Orthographic";
+/**
+ * The extensible list of supported navigation modes.
+ */
+export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
+/**
+ * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ */
+export interface NavigationMode {
+    /** The unique ID of this navigation mode. */
+    id: NavModeID;
     /**
-     * The horizontal dimension of the minimap.
-     */
-    get sizeX(): number;
+     * Enable or disable this navigation mode.
+     * When a new navigation mode is enabled, the previous navigation mode
+     * must be disabled.
+     *
+     * @param active - whether to enable or disable this mode.
+     * @param options - any additional data required to enable or disable it.
+     * */
+    set: (active: boolean, options?: any) => void;
+    /** Whether this navigation mode is active or not. */
+    enabled: boolean;
+}
+import * as THREE from "three";
+import { Disposable, Event } from "../../Types";
+/**
+ * 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 horizontal dimension of the minimap.
+     * The real position of the mouse of the Three.js canvas.
      */
-    set sizeX(value: number);
+    get position(): THREE.Vector2;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private getPositionY;
+    private getPositionX;
+    private updateMouseInfo;
+    private getDataObject;
+    private setupEvents;
+}
+import * as THREE from "three";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+import { Mouse } from "./mouse";
+/**
+ * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
+ */
+export declare class SimpleRaycaster implements Disposable {
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /** The components instance to which this Raycaster belongs. */
+    components: Components;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** The position of the mouse in the screen. */
+    readonly mouse: Mouse;
     /**
-     * The vertical dimension of the minimap.
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
      */
-    get sizeY(): number;
+    readonly three: THREE.Raycaster;
     /**
-     * The vertical dimension of the minimap.
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
      */
-    set sizeY(value: number);
+    world: World;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * The color of the background of the minimap.
+     * 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}.
      */
-    get backgroundColor(): THREE.Color;
+    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
     /**
-     * The color of the background of the minimap.
+     * 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.
      */
-    set backgroundColor(value: THREE.Color);
+    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;
 }
-export {};
 import { SimplePlane } from "../../Clipper";
 import { DataSet } from "../../Types";
 export interface ViewpointCamera {
@@ -4379,73 +4445,6 @@ export interface BCFViewpoint {
     defaultVisibility: boolean;
 }
 import * as THREE from "three";
-import { Event, World } from "../../Types";
-import { Components } from "../../Components";
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class DistanceRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
-     */
-    readonly onDistanceComputed: Event<number>;
-    /**
-     * Objects that won't be taken into account in the distance check.
-     */
-    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
-    /**
-     * Whether this renderer is active or not. If not, it won't render anything.
-     */
-    enabled: boolean;
-    /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
-     */
-    renderDebugFrame: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /**
-     * The scene where the distance is computed.
-     */
-    scene: THREE.Scene;
-    /**
-     * The camera used to compute the distance.
-     */
-    camera: THREE.OrthographicCamera;
-    /**
-     * The material used to compute the distance.
-     */
-    depthMaterial: THREE.ShaderMaterial;
-    /** The world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected readonly worker: Worker;
-    private _width;
-    private _height;
-    private readonly _postQuad;
-    private readonly tempRT;
-    private readonly resultRT;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
-     */
-    compute: () => Promise<void>;
-    private handleWorkerMessage;
-}
-import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { BCFViewpoint, ViewpointOrthographicCamera, ViewpointPerspectiveCamera } from "./types";
 import { CameraProjection } from "../../OrthoPerspectiveCamera";
@@ -4741,54 +4740,135 @@ export declare class SimplePlane implements Disposable, Hideable {
     private newHelper;
     private static newPlaneMesh;
 }
-import { IfcFragmentSettings } from "../../IfcLoader/src";
-/**
- * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
- */
-export declare class IfcStreamingSettings extends IfcFragmentSettings {
-    /**
-     * Minimum number of geometries to be streamed.
-     * Defaults to 10 geometries.
-     */
-    minGeometrySize: number;
-    /**
-     * Minimum amount of assets to be streamed.
-     * Defaults to 1000 assets.
-     */
-    minAssetsSize: number;
-    /**
-     * Maximum amount of triangles per fragment. Useful for controlling the maximum size of fragment files.
-     */
-    maxTriangles: number | null;
+import { IfcFragmentSettings } from "../../IfcLoader/src";
+/**
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ */
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    /**
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
+     */
+    propertiesSize: number;
+}
+import * as THREE from "three";
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+export declare class CivilReader {
+    defLineMat: THREE.LineBasicMaterial;
+    read(webIfc: WEBIFC.IfcAPI): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    get(civilItems: any): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    private getCurves;
+}
+import * as WEBIFC from "web-ifc";
+export declare class IfcMetadataReader {
+    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+}
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createEntityFacets: (components: Components, elements: any) => IDSFacet[];
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createAttributeFacets: (components: Components, elements: any) => IDSFacet[];
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createClassificationFacets: (components: Components, elements: any) => IDSFacet[];
+export type IfcVersion = "IFC2X3" | "IFC4" | "IFC4X3_ADD2";
+export type IDSFacetParameterName = "Name" | "PredefinedType" | "Value" | "System" | "URI" | "PropertySet" | "BaseName" | "DataType" | "Value" | "Entity" | "Relation";
+export type IDSSimpleCardinality = "required" | "prohibited";
+export type IDSConditionalCardinaltiy = IDSSimpleCardinality | "optional";
+export type IDSSimpleParameter = string | number | boolean;
+export type IDSEnumerationParameter = string[] | number[] | boolean[];
+export type IDSPatternParameter = string;
+export type IDSBoundsParameter = {
+    min?: number;
+    minInclusive?: boolean;
+    max?: number;
+    maxInclusive?: boolean;
+};
+export type IDSLengthParameter = {
+    min?: number;
+    length?: number;
+    max?: number;
+};
+export interface IDSRestrictionParameter {
+}
+export type IDSFacetParameterType = "simple" | "enumeration" | "pattern" | "bounds" | "length";
+export interface IDSFacetParameter {
+    type: IDSFacetParameterType;
+    parameter: IDSSimpleParameter | IDSEnumerationParameter | IDSPatternParameter | IDSBoundsParameter | IDSLengthParameter;
+}
+export interface IDSCheck {
+    parameter: IDSFacetParameterName;
+    currentValue: string | number | boolean | null;
+    requiredValue: any;
+    pass: boolean;
 }
 /**
- * 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.
+ * Represents the result of a check performed by an IDSFacet test.
  */
-export interface StreamedGeometries {
-    [id: number]: {
-        /** The bounding box of the geometry as a Float32Array. */
-        boundingBox: Float32Array;
-        /** A boolean indicating whether the geometry has holes. */
-        hasHoles: boolean;
-        /** An optional file path for the geometry data. */
-        geometryFile?: string;
-    };
+export interface IDSCheckResult {
+    guid?: string;
+    expressID: number;
+    pass: boolean;
+    checks: IDSCheck[];
+    cardinality: IDSConditionalCardinaltiy;
+}
+export interface IDSInfo {
+    title: string;
+    description?: string;
+    copyright?: string;
+    version?: string;
+    author?: string;
+    date?: Date;
+    purpose?: string;
+    milestone?: string;
 }
+import * as FRAGS from "@thatopen/fragments";
+import { Components } from "../../../core/Components";
+import { DataSet } from "../../../core/Types";
+import { IDSCheckResult, IfcVersion } from "./types";
+import { IDSFacet } from "./facets";
 /**
- * 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.
+ * Represents a single specification from the Information Delivery Specification (IDS) standard.
+ *
+ * @remarks This class provides methods for testing a model against the specification,
+ * as well as serializing the specification into XML format.
  */
-export interface StreamedAsset {
-    /** The unique identifier of the asset. */
-    id: number;
-    /** An array of geometries associated with the asset. */
-    geometries: {
-        /** The unique identifier of the geometry. */
-        geometryID: number;
-        /** The transformation matrix of the geometry as a number array. */
-        transformation: number[];
-        /** The color of the geometry as a number array. */
-        color: number[];
-    }[];
+export declare class IDSSpecification {
+    name: string;
+    ifcVersion: Set<IfcVersion>;
+    identifier: string;
+    description?: string;
+    instructions?: string;
+    requirementsDescription?: string;
+    applicability: DataSet<IDSFacet>;
+    requirements: DataSet<IDSFacet>;
+    protected components: Components;
+    constructor(components: Components, name: string, ifcVersion: IfcVersion[]);
+    /**
+     * Tests the model to test against the specification's requirements.
+     *
+     * @param model - The model to be tested.
+     * @returns An array representing the test results.
+     * If no requirements are defined for the specification, an empty array is returned.
+     */
+    test(model: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
+    /**
+     * Serializes the IDSSpecification instance into XML format.
+     *
+     * @remarks This method is not meant to be used directly. It is used by the IDSSpecifications component.
+     *
+     * @returns The XML representation of the IDSSpecification.
+     */
+    serialize(): string;
 }
 /**
  * A rule for the {@link IfcFinder} to search items based on their category.
@@ -4874,26 +4954,6 @@ export type SerializedQuery = {
         [key: string]: any;
     }[];
 };
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-}
-import * as THREE from "three";
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-export declare class CivilReader {
-    defLineMat: THREE.LineBasicMaterial;
-    read(webIfc: WEBIFC.IfcAPI): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    get(civilItems: any): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    private getCurves;
-}
 import * as FRAGS from "@thatopen/fragments";
 import { IfcFinderRule, SerializedQuery } from "./types";
 import { Components, Event } from "../../../core";
@@ -4991,13 +5051,13 @@ export declare abstract class IfcFinderQuery {
     protected getAttributesFromLine(line: string): string[] | null;
 }
 import * as FRAGS from "@thatopen/fragments";
+import { IfcFinderRule, SerializedQuery } from "./types";
 import { IfcFinderQuery } from "./ifc-finder-query";
-import { IfcOperatorRule, IfcPropertyRule, SerializedQuery } from "./types";
 import { Components } from "../../../core";
 /**
- * A query that checks the properties in the property sets assigned to IFC items.
+ * A query that checks the direct attributes of IFC items.
  */
-export declare class IfcPropertyQuery extends IfcFinderQuery {
+export declare class IfcBasicQuery extends IfcFinderQuery {
     /**
      * {@link IfcFinderQuery.name}
      */
@@ -5005,16 +5065,15 @@ export declare class IfcPropertyQuery extends IfcFinderQuery {
     /**
      * The type of this query.
      */
-    static type: "IfcPropertyQuery";
-    private psets;
+    static type: "IfcBasicQuery";
     /**
      * {@link IfcFinderQuery.items}
      */
     get items(): FRAGS.FragmentIdMap;
     constructor(components: Components, data: {
         name: string;
+        rules: IfcFinderRule[];
         inclusive: boolean;
-        rules: (IfcPropertyRule | IfcOperatorRule)[];
     });
     /**
      * {@link IfcFinderQuery.export}
@@ -5026,75 +5085,21 @@ export declare class IfcPropertyQuery extends IfcFinderQuery {
     update(modelID: string, file: File): Promise<void>;
     protected findInLines(modelID: string, lines: string[]): void;
 }
-import * as WEBIFC from "web-ifc";
-import * as THREE from "three";
-export declare class Units {
-    factor: number;
-    complement: number;
-    apply(matrix: THREE.Matrix4): void;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    private getLengthUnits;
-    private getScaleMatrix;
-}
-export type IfcVersion = "IFC2X3" | "IFC4" | "IFC4X3_ADD2";
-export type IDSFacetParameterName = "Name" | "PredefinedType" | "Value" | "System" | "URI" | "PropertySet" | "BaseName" | "DataType" | "Value" | "Entity" | "Relation";
-export type IDSSimpleCardinality = "required" | "prohibited";
-export type IDSConditionalCardinaltiy = IDSSimpleCardinality | "optional";
-export type IDSSimpleParameter = string | number | boolean;
-export type IDSEnumerationParameter = string[] | number[] | boolean[];
-export type IDSPatternParameter = string;
-export type IDSBoundsParameter = {
-    min?: number;
-    minInclusive?: boolean;
-    max?: number;
-    maxInclusive?: boolean;
-};
-export type IDSLengthParameter = {
-    min?: number;
-    length?: number;
-    max?: number;
+import { IfcRelName } from "./types";
+type IfcRelAttributePosition = {
+    related: number;
+    relating: number;
 };
-export interface IDSRestrictionParameter {
-}
-export type IDSFacetParameterType = "simple" | "enumeration" | "pattern" | "bounds" | "length";
-export interface IDSFacetParameter {
-    type: IDSFacetParameterType;
-    parameter: IDSSimpleParameter | IDSEnumerationParameter | IDSPatternParameter | IDSBoundsParameter | IDSLengthParameter;
-}
-export interface IDSCheck {
-    parameter: IDSFacetParameterName;
-    currentValue: string | number | boolean | null;
-    requiredValue: any;
-    pass: boolean;
-}
-/**
- * Represents the result of a check performed by an IDSFacet test.
- */
-export interface IDSCheckResult {
-    guid?: string;
-    expressID: number;
-    pass: boolean;
-    checks: IDSCheck[];
-    cardinality: IDSConditionalCardinaltiy;
-}
-export interface IDSInfo {
-    title: string;
-    description?: string;
-    copyright?: string;
-    version?: string;
-    author?: string;
-    date?: Date;
-    purpose?: string;
-    milestone?: string;
-}
+export declare const ifcRelAttrsPosition: Record<IfcRelName, IfcRelAttributePosition>;
+export {};
 import * as FRAGS from "@thatopen/fragments";
-import { IfcFinderRule, SerializedQuery } from "./types";
 import { IfcFinderQuery } from "./ifc-finder-query";
+import { IfcOperatorRule, IfcPropertyRule, SerializedQuery } from "./types";
 import { Components } from "../../../core";
 /**
- * A query that checks the direct attributes of IFC items.
+ * A query that checks the properties in the property sets assigned to IFC items.
  */
-export declare class IfcBasicQuery extends IfcFinderQuery {
+export declare class IfcPropertyQuery extends IfcFinderQuery {
     /**
      * {@link IfcFinderQuery.name}
      */
@@ -5102,73 +5107,28 @@ export declare class IfcBasicQuery extends IfcFinderQuery {
     /**
      * The type of this query.
      */
-    static type: "IfcBasicQuery";
+    static type: "IfcPropertyQuery";
+    private psets;
     /**
      * {@link IfcFinderQuery.items}
      */
     get items(): FRAGS.FragmentIdMap;
     constructor(components: Components, data: {
         name: string;
-        rules: IfcFinderRule[];
-        inclusive: boolean;
-    });
-    /**
-     * {@link IfcFinderQuery.export}
-     */
-    export(): SerializedQuery;
-    /**
-     * {@link IfcFinderQuery.update}
-     */
-    update(modelID: string, file: File): Promise<void>;
-    protected findInLines(modelID: string, lines: string[]): void;
-}
-import * as FRAGS from "@thatopen/fragments";
-import { Components } from "../../../core/Components";
-import { DataSet } from "../../../core/Types";
-import { IDSCheckResult, IfcVersion } from "./types";
-import { IDSFacet } from "./facets";
-/**
- * Represents a single specification from the Information Delivery Specification (IDS) standard.
- *
- * @remarks This class provides methods for testing a model against the specification,
- * as well as serializing the specification into XML format.
- */
-export declare class IDSSpecification {
-    name: string;
-    ifcVersion: Set<IfcVersion>;
-    identifier: string;
-    description?: string;
-    instructions?: string;
-    requirementsDescription?: string;
-    applicability: DataSet<IDSFacet>;
-    requirements: DataSet<IDSFacet>;
-    protected components: Components;
-    constructor(components: Components, name: string, ifcVersion: IfcVersion[]);
-    /**
-     * Tests the model to test against the specification's requirements.
-     *
-     * @param model - The model to be tested.
-     * @returns An array representing the test results.
-     * If no requirements are defined for the specification, an empty array is returned.
+        inclusive: boolean;
+        rules: (IfcPropertyRule | IfcOperatorRule)[];
+    });
+    /**
+     * {@link IfcFinderQuery.export}
      */
-    test(model: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
+    export(): SerializedQuery;
     /**
-     * Serializes the IDSSpecification instance into XML format.
-     *
-     * @remarks This method is not meant to be used directly. It is used by the IDSSpecifications component.
-     *
-     * @returns The XML representation of the IDSSpecification.
+     * {@link IfcFinderQuery.update}
      */
-    serialize(): string;
+    update(modelID: string, file: File): Promise<void>;
+    protected findInLines(modelID: string, lines: string[]): void;
 }
 import { IfcRelName } from "./types";
-type IfcRelAttributePosition = {
-    related: number;
-    relating: number;
-};
-export declare const ifcRelAttrsPosition: Record<IfcRelName, IfcRelAttributePosition>;
-export {};
-import { IfcRelName } from "./types";
 import { IfcRelation } from "../../IfcRelationsIndexer";
 export declare const ifcRelClassNames: Record<IfcRelation, IfcRelName>;
 export type IfcRelationNames = [
@@ -5189,16 +5149,66 @@ export type IfcRelationNames = [
     "IfcRelDefinesByTemplate"
 ];
 export type IfcRelName = IfcRelationNames[number];
+import * as WEBIFC from "web-ifc";
+import * as THREE from "three";
+export declare class Units {
+    factor: number;
+    complement: number;
+    apply(matrix: THREE.Matrix4): void;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    private getLengthUnits;
+    private getScaleMatrix;
+}
+import { IDSFacetParameter } from "../types";
+export declare const getParameterValue: (property: any) => IDSFacetParameter | undefined;
 import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
- * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
  */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
     /**
-     * Amount of properties to be streamed.
-     * Defaults to 100 properties.
+     * Minimum number of geometries to be streamed.
+     * Defaults to 10 geometries.
      */
-    propertiesSize: number;
+    minGeometrySize: number;
+    /**
+     * Minimum amount of assets to be streamed.
+     * Defaults to 1000 assets.
+     */
+    minAssetsSize: number;
+    /**
+     * Maximum amount of triangles per fragment. Useful for controlling the maximum size of fragment files.
+     */
+    maxTriangles: number | null;
+}
+/**
+ * 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 WEBIFC from "web-ifc";
 export type RelationsMap = Map<number, Map<number, number[]>>;
@@ -5257,15 +5267,6 @@ export type IfcRelations = [
     typeof WEBIFC.IFCRELASSOCIATESDOCUMENT
 ];
 export type IfcRelation = IfcRelations[number];
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "../facets";
-export declare const createEntityFacets: (components: Components, elements: any) => IDSFacet[];
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "../facets";
-export declare const createAttributeFacets: (components: Components, elements: any) => IDSFacet[];
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "../facets";
-export declare const createClassificationFacets: (components: Components, elements: any) => IDSFacet[];
 import { Components } from "../../../core/Components";
 import { Viewpoint } from "../../../core/Viewpoints";
 import { Comment } from "./Comment";
@@ -5389,6 +5390,25 @@ export declare class Topic implements BCFTopic {
      */
     serialize(): string;
 }
+export type BCFVersion = "2.1" | "3";
+export interface BCFTopic {
+    guid: string;
+    serverAssignedId?: string;
+    type: string;
+    status: string;
+    title: string;
+    priority?: string;
+    index?: number;
+    labels: Set<string>;
+    creationDate: Date;
+    creationAuthor: string;
+    modifiedDate?: Date;
+    modifiedAuthor?: string;
+    dueDate?: Date;
+    assignedTo?: string;
+    description?: string;
+    stage?: string;
+}
 import { Topic } from "..";
 import { Viewpoint } from "../../../core/Viewpoints";
 import { Components } from "../../../core/Components";
@@ -5429,27 +5449,6 @@ export declare class Comment {
      */
     serialize(): string;
 }
-export type BCFVersion = "2.1" | "3";
-export interface BCFTopic {
-    guid: string;
-    serverAssignedId?: string;
-    type: string;
-    status: string;
-    title: string;
-    priority?: string;
-    index?: number;
-    labels: Set<string>;
-    creationDate: Date;
-    creationAuthor: string;
-    modifiedDate?: Date;
-    modifiedAuthor?: string;
-    dueDate?: Date;
-    assignedTo?: string;
-    description?: string;
-    stage?: string;
-}
-import { IDSFacetParameter } from "../types";
-export declare const getParameterValue: (property: any) => IDSFacetParameter | undefined;
 import { BCFTopics, BCFVersion } from "../index";
 import { BooleanSettingsControl, Configurator, SelectSettingControl, TextSetSettingControl, TextSettingsControl } from "../../../core";
 /**
@@ -5572,6 +5571,18 @@ export declare class BCFTopicsConfigManager extends Configurator<BCFTopics, BCFT
     set ignoreIncompleteTopicsOnImport(value: boolean);
 }
 export {};
+import * as FRAGS from "@thatopen/fragments";
+import { IDSCheckResult, IDSFacetParameter } from "../types";
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "./Facet";
+export declare class IDSAttribute extends IDSFacet {
+    name: IDSFacetParameter;
+    value?: IDSFacetParameter;
+    constructor(components: Components, name: IDSFacetParameter);
+    serialize(type: "applicability" | "requirement"): string;
+    getEntities(): Promise<never[]>;
+    test(entities: FRAGS.IfcProperties): Promise<IDSCheckResult[]>;
+}
 import { BooleanSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
 import { CullerRenderer } from "../index";
@@ -5648,28 +5659,23 @@ export declare class CullerRendererConfigManager extends Configurator<CullerRend
 export {};
 import * as FRAGS from "@thatopen/fragments";
 import { Components } from "../../../../core/Components";
-import { IDSFacetParameter, IDSCheckResult, IDSFacetParameterName, IDSCheck, IDSConditionalCardinaltiy, IDSSimpleCardinality } from "../types";
-export declare abstract class IDSFacet {
-    protected components: Components;
-    cardinality: IDSSimpleCardinality | IDSConditionalCardinaltiy;
-    instructions?: string;
-    constructor(components: Components);
-    protected addCheckResult(check: IDSCheck, checks: IDSCheck[]): void;
-    protected evalRequirement: (value: string | number | boolean | null, facetParameter: IDSFacetParameter, parameter: IDSFacetParameterName, checks?: IDSCheck[]) => boolean;
-    protected testResult: IDSCheckResult[];
-    protected saveResult(attrs: any, pass: boolean): void;
-    /**
-     * Returns the list of expressIDs that pass the criteria of this facet.
-     * @param model - The IFC model to retrieve entities from.
-     * @param collector - An optional object to collect the retrieved entities.
-     * @remarks
-     * If the collector already includes the entity, it won't get processed any further.
-     *
-     * @returns An array of express IDs of the retrieved entities.
-     */
-    abstract getEntities(model: FRAGS.FragmentsGroup, collector: FRAGS.IfcProperties): Promise<number[]>;
-    abstract test(entities: FRAGS.IfcProperties, model?: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
-    abstract serialize(type: "applicability" | "requirement"): string;
+import { IDSCheckResult, IDSFacetParameter } from "../types";
+import { IDSFacet } from "./Facet";
+export declare class IDSClassification extends IDSFacet {
+    system: IDSFacetParameter;
+    value?: IDSFacetParameter;
+    uri?: string;
+    constructor(components: Components, system: IDSFacetParameter);
+    serialize(type: "applicability" | "requirement"): string;
+    getEntities(model: FRAGS.FragmentsGroup, collector?: FRAGS.IfcProperties): Promise<number[]>;
+    test(entities: FRAGS.IfcProperties, model: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
+    private processReferencedSource;
+    private getSystems;
+    private getSystemName;
+    private getAllReferenceIdentifications;
+    private evalSystem;
+    private evalValue;
+    private evalURI;
 }
 import * as FRAGS from "@thatopen/fragments";
 import { Components } from "../../../../core/Components";
@@ -5702,6 +5708,8 @@ export declare class IDSProperty extends IDSFacet {
     test(entities: FRAGS.IfcProperties, model: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
     private getItemsAttrName;
     private getValueKey;
+    private getPsetProps;
+    private getTypePsets;
     private getPsets;
     private evalValue;
     private evalDataType;
@@ -5709,43 +5717,47 @@ export declare class IDSProperty extends IDSFacet {
 }
 import * as FRAGS from "@thatopen/fragments";
 import { Components } from "../../../../core/Components";
-import { IDSCheckResult, IDSFacetParameter } from "../types";
-import { IDSFacet } from "./Facet";
-export declare class IDSClassification extends IDSFacet {
-    system: IDSFacetParameter;
-    value?: IDSFacetParameter;
-    uri?: string;
-    constructor(components: Components, system: IDSFacetParameter);
-    serialize(type: "applicability" | "requirement"): string;
-    getEntities(model: FRAGS.FragmentsGroup, collector?: FRAGS.IfcProperties): Promise<number[]>;
-    test(entities: FRAGS.IfcProperties, model: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
-    private processReferencedSource;
-    private getSystems;
-    private getSystemName;
-    private getAllReferenceIdentifications;
-    private evalSystem;
-    private evalValue;
-    private evalURI;
+import { IDSFacetParameter, IDSCheckResult, IDSFacetParameterName, IDSCheck, IDSConditionalCardinaltiy, IDSSimpleCardinality } from "../types";
+export declare abstract class IDSFacet {
+    protected components: Components;
+    cardinality: IDSSimpleCardinality | IDSConditionalCardinaltiy;
+    instructions?: string;
+    constructor(components: Components);
+    protected addCheckResult(check: IDSCheck, checks: IDSCheck[]): void;
+    protected evalRequirement: (value: string | number | boolean | null, facetParameter: IDSFacetParameter, parameter: IDSFacetParameterName, checks?: IDSCheck[]) => boolean;
+    protected testResult: IDSCheckResult[];
+    protected saveResult(attrs: any, pass: boolean): void;
+    /**
+     * Returns the list of expressIDs that pass the criteria of this facet.
+     * @param model - The IFC model to retrieve entities from.
+     * @param collector - An optional object to collect the retrieved entities.
+     * @remarks
+     * If the collector already includes the entity, it won't get processed any further.
+     *
+     * @returns An array of express IDs of the retrieved entities.
+     */
+    abstract getEntities(model: FRAGS.FragmentsGroup, collector: FRAGS.IfcProperties): Promise<number[]>;
+    abstract test(entities: FRAGS.IfcProperties, model?: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
+    abstract serialize(type: "applicability" | "requirement"): string;
 }
 import { BCFTopics } from "../..";
 export declare const extensionsImporter: (manager: BCFTopics, extensionsXML: string) => void;
-import * as FRAGS from "@thatopen/fragments";
-import { IDSCheckResult, IDSFacetParameter } from "../types";
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "./Facet";
-export declare class IDSAttribute extends IDSFacet {
-    name: IDSFacetParameter;
-    value?: IDSFacetParameter;
-    constructor(components: Components, name: IDSFacetParameter);
-    serialize(type: "applicability" | "requirement"): string;
-    getEntities(): Promise<never[]>;
-    test(entities: FRAGS.IfcProperties): Promise<IDSCheckResult[]>;
-}
 import { BufferGeometry } from "three";
 import * as THREE from "three";
 export declare class TransformHelper {
     getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
 }
+import { IDSFacetParameter } from "../types";
+import { IDSFacet } from "./Facet";
+export declare class IdsMaterialFacet extends IDSFacet {
+    value?: IDSFacetParameter;
+    uri?: string;
+    serialize(type: "applicability" | "requirement"): string;
+    getEntities(): Promise<number[]>;
+    test(): Promise<import("../types").IDSCheckResult[]>;
+}
+import { IDSFacetParameterName, IDSFacetParameter } from "../types";
+export declare const getParameterXML: (name: IDSFacetParameterName, parameter?: IDSFacetParameter) => string;
 import * as FRAGS from "@thatopen/fragments";
 import { Components } from "../../../../core/Components";
 import { IDSFacet } from "./Facet";
@@ -5771,16 +5783,5 @@ export declare class IDSPartOf extends IDSFacet {
     getEntities(model: FRAGS.FragmentsGroup, collector?: FRAGS.IfcProperties): Promise<number[]>;
     test(entities: FRAGS.IfcProperties, model: FRAGS.FragmentsGroup): Promise<import("../types").IDSCheckResult[]>;
 }
-import { IDSFacetParameter } from "../types";
-import { IDSFacet } from "./Facet";
-export declare class IdsMaterialFacet extends IDSFacet {
-    value?: IDSFacetParameter;
-    uri?: string;
-    serialize(type: "applicability" | "requirement"): string;
-    getEntities(): Promise<number[]>;
-    test(): Promise<import("../types").IDSCheckResult[]>;
-}
-import { IDSFacetParameterName, IDSFacetParameter } from "../types";
-export declare const getParameterXML: (name: IDSFacetParameterName, parameter?: IDSFacetParameter) => string;
 
 }