@thatopen/components 2.3.13 → 2.3.15

package/dist/namespace.d.ts

@@ -7,7 +7,7 @@ export declare class Components implements Disposable {
     /**
      * The version of the @thatopen/components library.
      */
-    static readonly release = "2.3.13";
+    static readonly release = "2.3.15";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
     /**
@@ -137,48 +137,6 @@ 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";
@@ -290,6 +248,66 @@ export declare class Worlds extends Component implements Updateable, Disposable
     /** {@link Updateable.update} */
     update(delta?: number): void | Promise<void>;
 }
+import * as THREE from "three";
+export declare function obbFromPoints(vertices: ArrayLike<number>): {
+    center: THREE.Vector3;
+    halfSizes: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    transformation: THREE.Matrix4;
+};
+import { Component, Disposable, World, Event } from "../Types";
+import { SimpleRaycaster } from "./src";
+import { Components } from "../Components";
+/**
+ * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
+ */
+export declare class Raycasters extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * A Map that stores raycasters for each world.
+     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     */
+    list: Map<string, SimpleRaycaster>;
+    /** {@link Disposable.onDisposed} */
+    onDisposed: Event<unknown>;
+    constructor(components: Components);
+    /**
+     * Retrieves a SimpleRaycaster instance for the given world.
+     * If a SimpleRaycaster instance already exists for the world, it will be returned.
+     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
+     *
+     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
+     * @returns The SimpleRaycaster instance for the given world.
+     */
+    get(world: World): SimpleRaycaster;
+    /**
+     * Deletes the SimpleRaycaster instance associated with the given world.
+     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
+     *
+     * @param world - The world for which to delete the SimpleRaycaster instance.
+     * @returns {void}
+     */
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+}
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
+export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
 import { Component, Disposable, World, Event } from "../Types";
 import { SimpleGrid } from "./src";
 import { Components } from "../Components";
@@ -336,6 +354,61 @@ export declare class Grids extends Component implements Disposable {
     dispose(): void;
 }
 import * as THREE from "three";
+import { Components } from "../Components";
+import { MeshCullerRenderer } from "./src";
+import { Component, Event, Disposable, World } from "../Types";
+/**
+ * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
+ */
+export declare class Cullers extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
+    /**
+     * An event that is triggered when the Cullers component is disposed.
+     */
+    readonly onDisposed: Event<unknown>;
+    private _enabled;
+    /**
+     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
+     */
+    list: Map<string, MeshCullerRenderer>;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(value: boolean);
+    constructor(components: Components);
+    /**
+     * Creates a new MeshCullerRenderer for the given world.
+     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
+     *
+     * @param world - The world for which to create the MeshCullerRenderer.
+     *
+     * @returns The newly created or existing MeshCullerRenderer for the given world.
+     */
+    create(world: World): MeshCullerRenderer;
+    /**
+     * Deletes the MeshCullerRenderer associated with the given world.
+     * If a MeshCullerRenderer exists for the given world, it will be disposed and removed from the list.
+     *
+     * @param world - The world for which to delete the MeshCullerRenderer.
+     *
+     * @returns {void}
+     */
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Updates the given instanced meshes inside the all the cullers. You should use this if you change the count property, e.g. when changing the visibility of fragments.
+     *
+     * @param meshes - The meshes to update.
+     *
+     */
+    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+}
+import * as THREE from "three";
 import { Component, Configurable, Createable, Disposable, Event, Hideable, World } from "../Types";
 import { SimplePlane } from "./src";
 import { Components } from "../Components";
@@ -476,60 +549,111 @@ export declare class Clipper extends Component implements Createable, Disposable
     private _onStartDragging;
     private _onEndDragging;
 }
-import * as THREE from "three";
+import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
+import { Components } from "../Components";
+import { BCFViewpoint, Viewpoint } from "./src";
+import { ViewpointsConfigManager, ViewpointsConfig } from "./src/viewpoints-config";
+export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfigManager, ViewpointsConfig> {
+    static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
+    enabled: boolean;
+    /**
+     * A DataMap that stores Viewpoint instances, indexed by their unique identifiers (guid).
+     * This map is used to manage and retrieve Viewpoint instances within the Viewpoints component.
+     */
+    readonly list: DataMap<string, Viewpoint>;
+    /**
+     * Creates a new Viewpoint instance and adds it to the list.
+     *
+     * @param world - The world in which the Viewpoint will be created.
+     * @param data - Optional partial data for the Viewpoint. If not provided, default data will be used.
+     *
+     * @returns The newly created Viewpoint instance.
+     */
+    create(world: World, data?: Partial<BCFViewpoint>): Viewpoint;
+    constructor(components: Components);
+    isSetup: boolean;
+    setup(): void;
+    onSetup: Event<unknown>;
+    config: ViewpointsConfigManager;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Disposes of the Viewpoints component and its associated resources.
+     *
+     * This method is responsible for cleaning up any resources held by the Viewpoints component,
+     * such as disposing of the DataMap of Viewpoint instances and triggering and resetting the
+     * onDisposed event.
+     */
+    dispose(): void;
+}
+import { MiniMap } from "./src";
+import { Component, Updateable, World, Event, Disposable } from "../Types";
 import { Components } from "../Components";
-import { MeshCullerRenderer } from "./src";
-import { Component, Event, Disposable, World } from "../Types";
 /**
- * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
+ * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
  */
-export declare class Cullers extends Component implements Disposable {
+export declare class MiniMaps extends Component implements Updateable, Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
-    /**
-     * An event that is triggered when the Cullers component is disposed.
-     */
+    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    private _enabled;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
+     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
      */
-    list: Map<string, MeshCullerRenderer>;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(value: boolean);
+    list: Map<string, MiniMap>;
     constructor(components: Components);
     /**
-     * Creates a new MeshCullerRenderer for the given world.
-     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
-     *
-     * @param world - The world for which to create the MeshCullerRenderer.
+     * Creates a new {@link MiniMap} instance associated with the given world.
+     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
      *
-     * @returns The newly created or existing MeshCullerRenderer for the given world.
+     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
+     * @returns The newly created {@link MiniMap} instance.
+     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
      */
-    create(world: World): MeshCullerRenderer;
+    create(world: World): MiniMap;
     /**
-     * Deletes the MeshCullerRenderer associated with the given world.
-     * If a MeshCullerRenderer exists for the given world, it will be disposed and removed from the list.
-     *
-     * @param world - The world for which to delete the MeshCullerRenderer.
+     * Deletes a {@link MiniMap} instance associated with the given world ID.
+     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
      *
+     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
      * @returns {void}
      */
-    delete(world: World): void;
+    delete(id: string): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /**
-     * Updates the given instanced meshes inside the all the cullers. You should use this if you change the count property, e.g. when changing the visibility of fragments.
-     *
-     * @param meshes - The meshes to update.
-     *
-     */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+    /** {@link Updateable.update} */
+    update(): 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 * as THREE from "three";
 import { Components } from "../Components";
@@ -595,345 +719,131 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
     private newOrthoCamera;
     private setOrthoPerspCameraAspect;
 }
-import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
-import { Components } from "../Components";
-import { BCFViewpoint, Viewpoint } from "./src";
-import { ViewpointsConfigManager, ViewpointsConfig } from "./src/viewpoints-config";
-export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfigManager, ViewpointsConfig> {
-    static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
-    enabled: boolean;
+import * as THREE from "three";
+import { Component, Components, Disposable, Event, World } from "../core";
+/**
+ * Configuration interface for the VertexPicker component.
+ */
+export interface VertexPickerConfig {
     /**
-     * A DataMap that stores Viewpoint instances, indexed by their unique identifiers (guid).
-     * This map is used to manage and retrieve Viewpoint instances within the Viewpoints component.
+     * If true, only vertices will be picked, not the closest point on the face.
      */
-    readonly list: DataMap<string, Viewpoint>;
+    showOnlyVertex: boolean;
     /**
-     * Creates a new Viewpoint instance and adds it to the list.
-     *
-     * @param world - The world in which the Viewpoint will be created.
-     * @param data - Optional partial data for the Viewpoint. If not provided, default data will be used.
-     *
-     * @returns The newly created Viewpoint instance.
+     * The maximum distance for snapping to a vertex.
      */
-    create(world: World, data?: Partial<BCFViewpoint>): Viewpoint;
-    constructor(components: Components);
-    isSetup: boolean;
-    setup(): void;
-    onSetup: Event<unknown>;
-    config: ViewpointsConfigManager;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    snapDistance: number;
     /**
-     * Disposes of the Viewpoints component and its associated resources.
-     *
-     * This method is responsible for cleaning up any resources held by the Viewpoints component,
-     * such as disposing of the DataMap of Viewpoint instances and triggering and resetting the
-     * onDisposed event.
+     * The HTML element to use for previewing the picked vertex.
      */
-    dispose(): void;
+    previewElement: HTMLElement;
 }
-import { Component, DataMap } from "../Types";
-import { Components } from "../Components";
-import { Configurator } from "./src";
 /**
- * A tool to manage all the configuration from the app centrally.
+ * A class that provides functionality for picking vertices in a 3D scene.
  */
-export declare class ConfigManager extends Component {
+export declare class VertexPicker extends Component implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * The list of all configurations of this app.
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
      */
-    list: DataMap<string, Configurator<any, any>>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    readonly onVertexFound: Event<THREE.Vector3>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
      */
-    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";
-/**
- * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
- */
-export declare class MiniMaps extends Component implements Updateable, Disposable {
+    readonly onVertexLost: Event<THREE.Vector3>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * An event that is triggered when the picker is enabled or disabled
      */
-    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    readonly onEnabled: Event<boolean>;
     /**
-     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
+     * A reference to the Components instance associated with this VertexPicker.
      */
-    list: Map<string, MiniMap>;
-    constructor(components: Components);
+    components: Components;
     /**
-     * Creates a new {@link MiniMap} instance associated with the given world.
-     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
-     *
-     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
-     * @returns The newly created {@link MiniMap} instance.
-     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
+     * 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.
      */
-    create(world: World): MiniMap;
+    workingPlane: THREE.Plane | null;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
     /**
-     * Deletes a {@link MiniMap} instance associated with the given world ID.
-     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
+     * 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 id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
-     * @returns {void}
-     */
-    delete(id: string): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
-}
-import { Component, Disposable, Event, Components } from "../../core";
-/**
- * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
- */
-export declare class Exploder extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * @param value - The new enabled state.
      */
-    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    set enabled(value: boolean);
     /**
-     * The height of the explosion animation.
-     * This property determines the vertical distance by which fragments are moved during the explosion.
-     * Default value is 10.
+     * Gets the current enabled state of the VertexPicker.
+     *
+     * @returns The current enabled state.
      */
-    height: number;
+    get enabled(): boolean;
     /**
-     * The group name used for the explosion animation.
-     * This property specifies the group of fragments that will be affected by the explosion.
-     * Default value is "storeys".
+     * 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,
+     * };
+     * '''
      */
-    groupName: string;
+    set config(value: Partial<VertexPickerConfig>);
     /**
-     * A set of strings representing the exploded items.
-     * This set is used to keep track of which items have been exploded.
+     * 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
+     * '''
      */
-    list: Set<string>;
-    constructor(components: Components);
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
-     * Sets the explosion state of the fragments.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the explosion.
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
      *
-     * @remarks
-     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
-     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
-     * If 'active' is false, the fragments are moved back to their original position.
+     * @param world - The World instance to use for raycasting.
      *
-     * The method also keeps track of the exploded items using the 'list' set.
+     * @returns The current picked point, or null if no point is picked.
      *
-     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
+     * @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'.
      */
-    set(active: boolean): void;
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
 }
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
-import { Disposable, Component, Event, Components } from "../../core";
-/**
- * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs with extra information.
- */
-export interface Classification {
-    /**
-     * A system within the classification.
-     * The key is the system name, and the value is an object representing the classes within the system.
-     */
-    [system: string]: {
-        /**
-         * A class within the system.
-         * The key is the class name, and the value is an object containing a map of fragment IDs with extra information.
-         */
-        [groupName: string]: {
-            map: FRAGS.FragmentIdMap;
-            name: string;
-            id: number | null;
-        };
-    };
-}
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Components, Disposable, Event } from "../../core";
 /**
- * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
+ * A 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 Classifier extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A map representing the classification systems.
-     * The key is the system name, and the value is an object representing the classes within the system.
-     */
-    list: Classification;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Removes a fragment from the classification based on its unique identifier (guid).
-     * This method iterates through all classification systems and classes, and deletes the fragment with the specified guid from the respective group.
-     *
-     * @param guid - The unique identifier of the fragment to be removed.
-     */
-    remove(guid: string): void;
-    /**
-     * Finds and returns fragments based on the provided filter criteria.
-     * If no filter is provided, it returns all fragments.
-     *
-     * @param filter - An optional object containing filter criteria.
-     * The keys of the object represent the classification system names,
-     * and the values are arrays of class names to match.
-     *
-     * @returns A map of fragment GUIDs to their respective express IDs,
-     * where the express IDs are filtered based on the provided filter criteria.
-     *
-     * @throws Will throw an error if the fragments map is malformed.
-     */
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
-    /**
-     * Classifies fragments based on their modelID.
-     *
-     * @param modelID - The unique identifier of the model to classify fragments by.
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the fragments in the provided group,
-     * and classifies them based on their modelID.
-     * The classification is stored in the 'list.models' property,
-     * with the modelID as the key and a map of fragment IDs to their respective express IDs as the value.
-     *
-     */
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
-    /**
-     * Classifies fragments based on their PredefinedType property.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the properties of the fragments in the provided group,
-     * and classifies them based on their PredefinedType property.
-     * The classification is stored in the 'list.predefinedTypes' property,
-     * with the PredefinedType as the key and a map of fragment IDs to their respective express IDs as the value.
-     *
-     * @throws Will throw an error if the fragment ID is not found.
-     */
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
-    /**
-     * Classifies fragments based on their entity type.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on their entity type.
-     * The classification is stored in the 'list.entities' property,
-     * with the entity type as the key and a map of fragment IDs to their respective express IDs as the value.
-     *
-     * @throws Will throw an error if the fragment ID is not found.
-     */
-    byEntity(group: FRAGS.FragmentsGroup): void;
-    /**
-     * Classifies fragments based on a specific IFC relationship.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     * @param ifcRel - The IFC relationship number to classify fragments by.
-     * @param systemName - The name of the classification system to store the classification.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on the specified IFC relationship.
-     * The classification is stored in the 'list' property under the specified system name,
-     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
-     *
-     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
-     */
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
-    /**
-     * Classifies fragments based on their spatial structure in the IFC model.
-     *
-     * @param model - The FragmentsGroup containing the fragments to be classified.
-     * @param config - The configuration for the classifier. It includes "useProperties", which is true by default
-     * (if false, the classification will use the expressIDs instead of the names), and "isolate", which will make
-     * the classifier just pick the WEBIFC categories provided.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on their spatial structure in the IFC model.
-     * The classification is stored in the 'list' property under the system name "spatialStructures",
-     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
-     *
-     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
-     */
-    bySpatialStructure(model: FRAGS.FragmentsGroup, config?: {
-        useProperties?: boolean;
-        isolate?: Set<number>;
-    }): Promise<void>;
-    /**
-     * Sets the color of the specified fragments.
-     *
-     * @param items - A map of fragment IDs to their respective express IDs.
-     * @param color - The color to set for the fragments.
-     * @param override - A boolean indicating whether to override the existing color of the fragments.
-     *
-     * @remarks
-     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
-     * and sets their color using the 'setColor' method of the FragmentsGroup class.
-     *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
-     */
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
-    /**
-     * Resets the color of the specified fragments to their original color.
-     *
-     * @param items - A map of fragment IDs to their respective express IDs.
-     *
-     * @remarks
-     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
-     * and resets their color using the 'resetColor' method of the FragmentsGroup class.
-     *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
-     */
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
-}
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Components, Disposable, Event } from "../../core";
-/**
- * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but it's fast, and should suffice for general use cases such as camera zooming or general boundary determination. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/BoundingBoxer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/BoundingBoxer).
- */
-export declare class BoundingBoxer extends Component implements Disposable {
-    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
+export declare class BoundingBoxer extends Component implements Disposable {
+    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
     /** {@link Component.enabled} */
     enabled: boolean;
     /** {@link Disposable.onDisposed} */
@@ -1133,177 +1043,267 @@ export declare class BoundingBoxer extends Component implements Disposable {
     addFragmentIdMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
     private static getFragmentBounds;
 }
+import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
+import { Disposable, Component, Event, Components } from "../../core";
 /**
- * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
+ * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs with extra information.
  */
-export declare class Hider extends Component {
+export interface Classification {
+    /**
+     * A system within the classification.
+     * The key is the system name, and the value is an object representing the classes within the system.
+     */
+    [system: string]: {
+        /**
+         * A class within the system.
+         * The key is the class name, and the value is an object containing a map of fragment IDs with extra information.
+         */
+        [groupName: string]: {
+            map: FRAGS.FragmentIdMap;
+            name: string;
+            id: number | null;
+        };
+    };
+}
+/**
+ * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
+ */
+export declare class Classifier extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
     /** {@link Component.enabled} */
     enabled: boolean;
+    /**
+     * A map representing the classification systems.
+     * The key is the system name, and the value is an object representing the classes within the system.
+     */
+    list: Classification;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     constructor(components: Components);
+    private onFragmentsDisposed;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * 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.
+     * Removes a fragment from the classification based on its unique identifier (guid).
+     * This method iterates through all classification systems and classes, and deletes the fragment with the specified guid from the respective group.
      *
-     * @returns {void}
+     * @param guid - The unique identifier of the fragment to be removed.
      */
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    remove(guid: string): 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.
+     * Finds and returns fragments based on the provided filter criteria.
+     * If no filter is provided, it returns all fragments.
      *
-     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
-     * If not provided, all fragments will be isolated.
+     * @param filter - An optional object containing filter criteria.
+     * The keys of the object represent the classification system names,
+     * and the values are arrays of class names to match.
      *
-     * @returns {void}
+     * @returns A map of fragment GUIDs to their respective express IDs,
+     * where the express IDs are filtered based on the provided filter criteria.
+     *
+     * @throws Will throw an error if the fragments map is malformed.
      */
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
-}
-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 {
+    find(filter?: {
+        [name: string]: string[];
+    }): FRAGS.FragmentIdMap;
     /**
-     * If true, only vertices will be picked, not the closest point on the face.
+     * Classifies fragments based on their modelID.
+     *
+     * @param modelID - The unique identifier of the model to classify fragments by.
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the fragments in the provided group,
+     * and classifies them based on their modelID.
+     * The classification is stored in the 'list.models' property,
+     * with the modelID as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
      */
-    showOnlyVertex: boolean;
+    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
     /**
-     * The maximum distance for snapping to a vertex.
+     * Classifies fragments based on their PredefinedType property.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the properties of the fragments in the provided group,
+     * and classifies them based on their PredefinedType property.
+     * The classification is stored in the 'list.predefinedTypes' property,
+     * with the PredefinedType as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found.
      */
-    snapDistance: number;
+    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
     /**
-     * The HTML element to use for previewing the picked vertex.
+     * Classifies fragments based on their entity type.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their entity type.
+     * The classification is stored in the 'list.entities' property,
+     * with the entity type as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found.
      */
-    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>;
+    byEntity(group: FRAGS.FragmentsGroup): void;
     /**
-     * An event that is triggered when a vertex is found.
-     * The event passes a THREE.Vector3 representing the position of the found vertex.
+     * Classifies fragments based on a specific IFC relationship.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     * @param ifcRel - The IFC relationship number to classify fragments by.
+     * @param systemName - The name of the classification system to store the classification.
+     *
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on the specified IFC relationship.
+     * The classification is stored in the 'list' property under the specified system name,
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
      */
-    readonly onVertexFound: Event<THREE.Vector3>;
+    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
     /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
+     * Classifies fragments based on their spatial structure in the IFC model.
+     *
+     * @param model - The FragmentsGroup containing the fragments to be classified.
+     * @param config - The configuration for the classifier. It includes "useProperties", which is true by default
+     * (if false, the classification will use the expressIDs instead of the names), and "isolate", which will make
+     * the classifier just pick the WEBIFC categories provided.
+     *
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their spatial structure in the IFC model.
+     * The classification is stored in the 'list' property under the system name "spatialStructures",
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
      */
-    readonly onVertexLost: Event<THREE.Vector3>;
+    bySpatialStructure(model: FRAGS.FragmentsGroup, config?: {
+        useProperties?: boolean;
+        isolate?: Set<number>;
+    }): Promise<void>;
     /**
-     * An event that is triggered when the picker is enabled or disabled
+     * Sets the color of the specified fragments.
+     *
+     * @param items - A map of fragment IDs to their respective express IDs.
+     * @param color - The color to set for the fragments.
+     * @param override - A boolean indicating whether to override the existing color of the fragments.
+     *
+     * @remarks
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and sets their color using the 'setColor' method of the FragmentsGroup class.
+     *
+     * @throws Will throw an error if the fragment with the specified ID is not found.
      */
-    readonly onEnabled: Event<boolean>;
+    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
     /**
-     * A reference to the Components instance associated with this VertexPicker.
+     * Resets the color of the specified fragments to their original color.
+     *
+     * @param items - A map of fragment IDs to their respective express IDs.
+     *
+     * @remarks
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and resets their color using the 'resetColor' method of the FragmentsGroup class.
+     *
+     * @throws Will throw an error if the fragment with the specified ID is not found.
      */
-    components: Components;
+    resetColor(items: FRAGS.FragmentIdMap): void;
+    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
+}
+import { Component, Disposable, Event, Components } from "../../core";
+/**
+ * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
+ */
+export declare class Exploder extends Component implements Disposable {
     /**
-     * A 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.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
+    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * 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.
+     * The height of the explosion animation.
+     * This property determines the vertical distance by which fragments are moved during the explosion.
+     * Default value is 10.
      */
-    set enabled(value: boolean);
+    height: number;
     /**
-     * Gets the current enabled state of the VertexPicker.
-     *
-     * @returns The current enabled state.
+     * The group name used for the explosion animation.
+     * This property specifies the group of fragments that will be affected by the explosion.
+     * Default value is "storeys".
      */
-    get enabled(): boolean;
+    groupName: string;
     /**
-     * Sets the configuration for the VertexPicker component.
+     * A set of strings representing the exploded items.
+     * This set is used to keep track of which items have been exploded.
+     */
+    list: Set<string>;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets the explosion state of the fragments.
      *
-     * @param value - A Partial object containing the configuration properties to update.
-     * The properties not provided in the value object will retain their current values.
+     * @param active - A boolean indicating whether to activate or deactivate the explosion.
      *
-     * @example
-     * '''typescript
-     * vertexPicker.config = {
-     *   snapDistance: 0.5,
-     *   showOnlyVertex: true,
-     * };
-     * '''
+     * @remarks
+     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
+     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
+     * If 'active' is false, the fragments are moved back to their original position.
+     *
+     * The method also keeps track of the exploded items using the 'list' set.
+     *
+     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
      */
-    set config(value: Partial<VertexPickerConfig>);
+    set(active: boolean): void;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
+/**
+ * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
+ */
+export declare class Hider extends Component {
     /**
-     * Gets the current configuration for the VertexPicker component.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Sets the visibility of fragments within the 3D scene.
+     * If no 'items' parameter is provided, all fragments will be set to the specified visibility.
+     * If 'items' is provided, only the specified fragments will be affected.
      *
-     * @returns A copy of the current VertexPickerConfig object.
+     * @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 currentConfig = vertexPicker.config;
-     * console.log(currentConfig.snapDistance); // Output: 0.25
-     * '''
+     * @returns {void}
      */
-    get config(): Partial<VertexPickerConfig>;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
     /**
-     * Performs the vertex picking operation based on the current state of the VertexPicker.
-     *
-     * @param world - The World instance to use for raycasting.
+     * 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 The current picked point, or null if no point is picked.
+     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
+     * If not provided, all fragments will be isolated.
      *
-     * @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'.
+     * @returns {void}
      */
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
 }
 import * as WEBIFC from "web-ifc";
 import * as FRAGS from "@thatopen/fragments";
@@ -1673,123 +1673,18 @@ export declare class IfcGeometryTiler extends Component implements Disposable {
     private streamGeometries;
     private registerGeometryData;
 }
-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[];
-}
+import * as WEBIFC from "web-ifc";
+import { AsyncEvent, Component, Disposable, Event } from "../../core";
+import { PropertiesStreamingSettings } from "./src";
 /**
- * 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).
+ * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
  */
-export declare class MeasurementUtils extends Component {
+export declare class IfcPropertiesTiler extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Utility method to calculate the distance from a point to a line segment.
-     *
-     * @param point - The point from which to calculate the distance.
-     * @param lineStart - The start point of the line segment.
-     * @param lineEnd - The end point of the line segment.
-     * @param clamp - If true, the distance will be clamped to the line segment's length.
-     * @returns The distance from the point to the line segment.
-     */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    /**
-     * Method to get the face of a mesh that contains a given triangle index.
-     * It also returns the edges of the found face and their indices.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param triangleIndex - The index of the triangle within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
-     */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
-     */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
-     *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
-     */
-    round(vector: THREE.Vector3): void;
-    /**
-     * Calculates the volume of a set of fragments.
-     *
-     * @param frags - A map of fragment IDs to their corresponding item IDs.
-     * @returns The total volume of the fragments and the bounding sphere.
-     *
-     * @remarks
-     * This method creates a set of instanced meshes from the given fragments and item IDs.
-     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
-     *
-     * @throws Will throw an error if the geometry of the meshes is not indexed.
-     * @throws Will throw an error if the fragment manager is not available.
-     */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
-    /**
-     * Calculates the total volume of a set of meshes.
-     *
-     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
-     * @returns The total volume of the meshes and the bounding sphere.
-     *
-     * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
-     *
-     */
-    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
-    private getFaceData;
-    private getVolumeOfMesh;
-    private getSignedVolumeOfTriangle;
-}
-import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../core";
-import { PropertiesStreamingSettings } from "./src";
-/**
- * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
- */
-export declare class IfcPropertiesTiler extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
     /**
      * An event that is triggered when properties are streamed from the IFC file.
      * The event provides the type of the IFC entity and the corresponding data.
@@ -2017,29 +1912,111 @@ export declare class IDSSpecifications extends Component {
      */
     export(info: IDSInfo, specifications?: Iterable<IDSSpecification>): string;
 }
-import { BooleanSettingsControl } from "../../Types";
-import { Viewpoints } from "../index";
-import { Configurator } from "../../ConfigManager";
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components } from "../../core";
 /**
- * Configuration interface for the Viewpoints general behavior.
+ * Represents an edge measurement result.
  */
-export interface ViewpointsConfig {
+export interface MeasureEdge {
     /**
-     * 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
+     * The distance between the two points of the edge.
      */
-    overwriteColors: boolean;
+    distance: number;
+    /**
+     * The two points that define the edge.
+     */
+    points: THREE.Vector3[];
 }
-type ViewpointsConfigType = {
-    overwriteColors: BooleanSettingsControl;
-};
-export declare class ViewpointsConfigManager extends Configurator<Viewpoints, ViewpointsConfigType> {
-    protected _config: ViewpointsConfigType;
-    get overwriteColors(): boolean;
-    set overwriteColors(value: boolean);
+/**
+ * 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;
 }
-export {};
 import * as WEBIFC from "web-ifc";
 import * as FRAG from "@thatopen/fragments";
 import { Component, Components } from "../../core";
@@ -2065,10 +2042,33 @@ export declare class IfcJsonExporter extends Component {
      */
     export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
+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 {};
 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";
+import { RelationsMap, ModelsRelationMap, InverseAttribute, IfcRelation, RelationsProcessingConfig, EntitiesRelatedEvent } 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).
  */
@@ -2109,7 +2109,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     constructor(components: Components);
     private onFragmentsDisposed;
     private indexRelations;
-    getAttributeIndex(inverseAttribute: InverseAttribute): number | null;
+    getAttributeIndex(inverseAttribute: InverseAttribute): number;
     /**
      * Adds a relation map to the model's relations map.
      *
@@ -2135,7 +2135,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      * representation of the relations indexed by entity expressIDs and relation types.
      * @throws An error if the model does not have properties loaded.
      */
-    process(model: FragmentsGroup): Promise<RelationsMap>;
+    process(model: FragmentsGroup, config?: Partial<RelationsProcessingConfig>): Promise<RelationsMap>;
     /**
      * Processes a given model from a WebIfc API to index its IFC entities relations.
      *
@@ -2152,11 +2152,10 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      *
      * @param model The 'FragmentsGroup' model containing the entity, or its UUID.
      * @param expressID The unique identifier of the entity within the model.
-     * @param relationName The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
-     * @returns An array of express IDs representing the related entities, or 'null' if no relations are found
-     * or the specified relation name is not indexed.
+     * @param attribute The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
+     * @returns An array of express IDs representing the related entities. If the array is empty, no relations were found.
      */
-    getEntityRelations(model: FragmentsGroup | string, expressID: number, relationName: InverseAttribute): number[] | null;
+    getEntityRelations(model: FragmentsGroup | string | RelationsMap, expressID: number, attribute: InverseAttribute): number[];
     /**
      * Serializes the relations of a given relation map into a JSON string.
      * This method iterates through the relations in the given map, organizing them into a structured object where each key is an expressID of an entity,
@@ -2233,7 +2232,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      * Converts the relations made into actual IFC data.
      *
      * @remarks This function iterates through the changes made to the relations and applies them to the corresponding BIM model.
-     * It only make sense to use if the relations need to be write in the IFC file.
+     * It only make sense to use it if the relations need to be write in the IFC file.
      *
      * @returns A promise that resolves when all the relation changes have been applied.
      */
@@ -2244,16 +2243,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      * The event provides information about the type of relation, the inverse attribute,
      * the IDs of the entities related, and the IDs of the entities that are being related.
      */
-    readonly onEntitiesRelated: Event<{
-        /** The type of the IFC relation. */
-        relType: IfcRelation;
-        /** The inverse attribute of the relation. */
-        invAttribute: InverseAttribute;
-        /** The IDs of the entities that are relating. */
-        relatingIDs: number[];
-        /** The IDs of the entities that are being related. */
-        relatedIDs: number[];
-    }>;
+    readonly onEntitiesRelated: Event<EntitiesRelatedEvent>;
     addEntitiesRelation(model: FragmentsGroup, relatingID: number, rel: {
         type: IfcRelation;
         inv: InverseAttribute;
@@ -2409,7 +2399,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.
@@ -2602,6 +2591,13 @@ export declare class IfcFinder extends Component {
      */
     clear(): 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 THREE from "three";
 import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
@@ -2635,84 +2631,23 @@ export declare class ClipperConfigManager extends Configurator<Clipper, ClipperC
     set size(value: number);
 }
 export {};
-import * as FRAGS from "@thatopen/fragments";
-import * as WEBIFC from "web-ifc";
-export declare class SpatialIdsFinder {
-    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
-}
-import * as WEBIFC from "web-ifc";
-/** Configuration of the IFC-fragment conversion. */
-export declare class IfcFragmentSettings {
-    /** Whether to extract the IFC properties into a JSON. */
-    includeProperties: boolean;
-    /**
-     * Generate the geometry for categories that are not included by default,
-     * like IFCSPACE.
-     */
-    optionalCategories: number[];
-    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    wasm: {
-        path: string;
-        absolute: boolean;
-        logLevel?: WEBIFC.LogLevel;
-    };
-    /** List of categories that won't be converted to fragments. */
-    excludedCategories: Set<number>;
-    /** Exclusive list of categories that will be converted to fragments. If this contains any category, any other categories will be ignored. */
-    includedCategories: Set<number>;
-    /** Whether to save the absolute location of all IFC items. */
-    saveLocations: boolean;
-    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    webIfc: WEBIFC.LoaderSettings;
-    /**
-     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * If set to true, the path will be set to the default path of the WASM file.
-     * If set to false, the path must be provided manually in the 'wasm.path' property.
-     * Default value is true.
-     */
-    autoSetWasm: boolean;
-    /**
-     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
-     * If set to null, the default file location handler will be used.
-     *
-     * @param url - The URL of the file to locate.
-     * @returns The absolute path of the file.
-     */
-    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
-}
-import * as WEBIFC from "web-ifc";
-import { IfcItemsCategories } from "../../../ifc";
-export declare class SpatialStructure {
-    itemsByFloor: IfcItemsCategories;
-    private _units;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    cleanUp(): void;
-}
-import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}
-/**
- * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
- *
- * @remarks
- * This map is used to provide a mapping between IFC entity type numbers and their names.
- * It is useful for identifying and processing different types of IFC elements in a project.
- *
- */
-export declare const IfcElements: {
-    [key: number]: string;
-};
-/**
- * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
- */
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
+/**
+ * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
+ *
+ * @remarks
+ * This map is used to provide a mapping between IFC entity type numbers and their names.
+ * It is useful for identifying and processing different types of IFC elements in a project.
+ *
+ */
+export declare const IfcElements: {
+    [key: number]: string;
+};
+/**
+ * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
+ */
+export declare const IfcCategoryMap: {
+    [key: number]: string;
+};
 import * as FRAGS from "@thatopen/fragments";
 export declare class IfcPropertiesUtils {
     static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
@@ -2741,13 +2676,26 @@ export declare class IfcPropertiesUtils {
 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 { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createPropertyFacets: (components: Components, elements: any) => IDSFacet[];
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
+}
+import * as FRAGS from "@thatopen/fragments";
+import * as WEBIFC from "web-ifc";
+export declare class SpatialIdsFinder {
+    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+}
 import * as FRAGS from "@thatopen/fragments";
 import { IfcFinderQuery } from "./ifc-finder-query";
 import { Components } from "../../../core";
@@ -2817,84 +2765,374 @@ export declare class IfcQueryGroup {
      */
     update(modelID: string, file: File): Promise<void>;
 }
-import * as THREE from "three";
-import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
-import { Components } from "../../Components";
-import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
-/**
- * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
- */
-export declare class SimpleGrid implements Hideable, Disposable, 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;
+import * as WEBIFC from "web-ifc";
+/** Configuration of the IFC-fragment conversion. */
+export declare class IfcFragmentSettings {
+    /** Whether to extract the IFC properties into a JSON. */
+    includeProperties: boolean;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Generate the geometry for categories that are not included by default,
+     * like IFCSPACE.
      */
-    get fade(): boolean;
+    optionalCategories: number[];
+    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    wasm: {
+        path: string;
+        absolute: boolean;
+        logLevel?: WEBIFC.LogLevel;
+    };
+    /** List of categories that won't be converted to fragments. */
+    excludedCategories: Set<number>;
+    /** Exclusive list of categories that will be converted to fragments. If this contains any category, any other categories will be ignored. */
+    includedCategories: Set<number>;
+    /** Whether to save the absolute location of all IFC items. */
+    saveLocations: boolean;
+    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    webIfc: WEBIFC.LoaderSettings;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * 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.
      */
-    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;
+    autoSetWasm: boolean;
+    /**
+     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
+     * If set to null, the default file location handler will be used.
+     *
+     * @param url - The URL of the file to locate.
+     * @returns The absolute path of the file.
+     */
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+import { 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;
+}>;
+import { SimplePlane } from "../../Clipper";
+import { DataSet } from "../../Types";
+export interface ViewpointCamera {
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    aspectRatio: number;
+}
+export interface ViewpointPerspectiveCamera extends ViewpointCamera {
+    fov: number;
+}
+export interface ViewpointOrthographicCamera extends ViewpointCamera {
+    viewToWorldScale: number;
+}
+/**
+ * Represents a viewpoint in a BCF file.
+ */
+export interface BCFViewpoint {
+    title?: string;
+    guid: string;
+    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
+    selectionComponents: Iterable<string>;
+    exceptionComponents: Iterable<string>;
+    clippingPlanes: DataSet<SimplePlane>;
+    spacesVisible: boolean;
+    spaceBoundariesVisible: boolean;
+    openingsVisible: boolean;
+    defaultVisibility: boolean;
 }
 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 * as FRAGS from "@thatopen/fragments";
+import { BCFViewpoint, ViewpointOrthographicCamera, ViewpointPerspectiveCamera } from "./types";
+import { CameraProjection } from "../../OrthoPerspectiveCamera";
+import { Components } from "../../Components";
+import { DataMap, DataSet, World } from "../../Types";
+import { SimplePlane } from "../../Clipper";
 /**
- * Configuration interface for the {@link SimpleGrid}.
+ * Represents a BCF compliant viewpoint from BuildingSMART.
+ *
+ * The Viewpoint class provides methods for managing and interacting with viewpoints.
+ * It includes functionality for setting viewpoint properties, updating the camera,
+ * applying color to components, and serializing the viewpoint for export.
  */
-export interface SimpleGridConfig {
+export declare class Viewpoint implements BCFViewpoint {
+    title?: string;
+    readonly guid: string;
     /**
-     * Whether the grid is visible or not.
+     * ClippingPlanes can be used to define a subsection of a building model that is related to the topic.
+     * Each clipping plane is defined by Location and Direction.
+     * The Direction vector points in the invisible direction meaning the half-space that is clipped.
+     * @experimental
      */
-    visible: boolean;
+    clippingPlanes: DataSet<SimplePlane>;
+    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
     /**
-     * The color of the grid lines.
+     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
      */
-    color: THREE.Color;
+    readonly exceptionComponents: DataSet<string>;
     /**
-     * The size of the primary grid lines.
+     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
      */
-    primarySize: number;
+    readonly selectionComponents: DataSet<string>;
     /**
-     * The size of the secondary grid lines.
-     */
+     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
+     * For this to work, call viewpoint.colorize()
+     */
+    readonly componentColors: DataMap<THREE.Color, string[]>;
+    /**
+     * Boolean flags to allow fine control over the visibility of spaces.
+     * A typical use of these flags is when DefaultVisibility=true but spaces should remain hidden.
+     * @default false
+     */
+    spacesVisible: boolean;
+    /**
+     * Boolean flags to allow fine control over the visibility of space boundaries.
+     * A typical use of these flags is when DefaultVisibility=true but space boundaries should remain hidden.
+     * @default false
+     */
+    spaceBoundariesVisible: boolean;
+    /**
+     * Boolean flags to allow fine control over the visibility of openings.
+     * A typical use of these flags is when DefaultVisibility=true but openings should remain hidden.
+     * @default false
+     */
+    openingsVisible: boolean;
+    /**
+     * When true, all components should be visible unless listed in the exceptions
+     * When false all components should be invisible unless listed in the exceptions
+     */
+    defaultVisibility: boolean;
+    private get _selectionModelIdMap();
+    private get _exceptionModelIdMap();
+    /**
+     * A list of components that should be selected (highlighted) when displaying a viewpoint.
+     * @returns The fragmentIdMap for components marked as selections.
+     */
+    get selection(): FRAGS.FragmentIdMap;
+    /**
+     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
+     * @returns The fragmentIdMap for components marked as exceptions.
+     */
+    get exception(): FRAGS.FragmentIdMap;
+    /**
+     * Retrieves the projection type of the viewpoint's camera.
+     *
+     * @returns A string representing the projection type of the viewpoint's camera.
+     *          It can be either 'Perspective' or 'Orthographic'.
+     */
+    get projection(): CameraProjection;
+    /**
+     * Retrieves the position vector of the viewpoint's camera.
+     *
+     * @remarks
+     * The position vector represents the camera's position in the world coordinate system.
+     * The function applies the base coordinate system transformation to the position vector.
+     *
+     * @returns A THREE.Vector3 representing the position of the viewpoint's camera.
+     */
+    get position(): THREE.Vector3;
+    /**
+     * Retrieves the direction vector of the viewpoint's camera.
+     *
+     * @remarks
+     * The direction vector represents the direction in which the camera is pointing.
+     * It is calculated by extracting the x, y, and z components from the camera's direction property.
+     *
+     * @returns A THREE.Vector3 representing the direction of the viewpoint's camera.
+     */
+    get direction(): THREE.Vector3;
+    private _components;
+    /**
+     * Represents the world in which the viewpoints are created and managed.
+     */
+    readonly world: World;
+    private get _managerVersion();
+    /**
+     * Retrieves the list of BCF topics associated with the current viewpoint.
+     *
+     * @remarks
+     * This function retrieves the BCFTopics manager from the components,
+     * then filters the list of topics to find those associated with the current viewpoint.
+     *
+     * @returns An array of BCF topics associated with the current viewpoint.
+     */
+    get topics(): import("../../../openbim/BCFTopics").Topic[];
+    constructor(components: Components, world: World, _config?: {
+        data?: Partial<BCFViewpoint>;
+        setCamera?: boolean;
+    });
+    /**
+     * Adds components to the viewpoint based on the provided fragment ID map.
+     *
+     * @param fragmentIdMap - A map containing fragment IDs as keys and arrays of express IDs as values.
+     */
+    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
+    /**
+     * Replace the properties of the viewpoint with the provided data.
+     *
+     * @remarks The guid will be ommited as it shouldn't change after it has been initially set.
+     * @remarks The existing selection and exception components will be fully replaced in case new ones are provided.
+     *
+     * @param data - An object containing the properties to be set.
+     *               The properties not included in the object will remain unchanged.
+     *
+     * @returns The viewpoint instance with the updated properties.
+     */
+    set(data: Partial<BCFViewpoint>): this;
+    /**
+     * Sets the viewpoint of the camera in the world.
+     *
+     * @remarks
+     * This function calculates the target position based on the viewpoint information.
+     * It sets the visibility of the viewpoint components and then applies the viewpoint using the camera's controls.
+     *
+     * @param transition - Indicates whether the camera movement should have a transition effect.
+     *                      Default value is 'true'.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     *
+     * @returns A Promise that resolves when the camera has been set.
+     */
+    go(transition?: boolean): Promise<void>;
+    /**
+     * Updates the camera settings of the viewpoint based on the current world's camera and renderer.
+     *
+     * @remarks
+     * This function retrieves the camera's position, direction, and aspect ratio from the world's camera and renderer.
+     * It then calculates the camera's perspective or orthographic settings based on the camera type.
+     * Finally, it updates the viewpoint's camera settings and updates the viewpoint to the Viewpoints manager.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     * @throws An error if the world's renderer is not available.
+     */
+    updateCamera(): void;
+    applyVisibility(): void;
+    /**
+     * Applies color to the components in the viewpoint based on their GUIDs.
+     *
+     * This function iterates through the 'componentColors' map, retrieves the fragment IDs
+     * corresponding to each color, and then uses the 'Classifier' to apply the color to those fragments.
+     *
+     * @remarks
+     * The color is applied using the 'Classifier.setColor' method, which sets the color of the specified fragments.
+     * The color is provided as a hexadecimal string, prefixed with a '#'.
+     */
+    applyColors(): void;
+    /**
+     * Resets the colors of all components in the viewpoint to their original color.
+     */
+    resetColors(): void;
+    private createComponentTags;
+    private createColorTags;
+    /**
+     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
+     *
+     * @param version - The version of the BCF Manager to use for serialization.
+     *                   If not provided, the current version of the manager will be used.
+     *
+     * @returns A Promise that resolves to an XML string representing the viewpoint.
+     *          The XML string follows the BCF VisualizationInfo schema.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     * @throws An error if the world's renderer is not available.
+     */
+    serialize(version?: string): Promise<string>;
+}
+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 { Hideable, Event, World, Disposable, Configurable } from "../../Types";
+import { Components } from "../../Components";
+import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
+/**
+ * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ */
+export declare class SimpleGrid implements Hideable, Disposable, 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 size of the secondary grid lines.
+     */
     secondarySize: number;
     /**
      * The distance at which the grid lines start to fade away.
@@ -3045,11 +3283,6 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable, Conf
     setup(config?: Partial<MiniMapConfig>): void;
     private updatePlanes;
 }
-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;
-}>;
 import * as THREE from "three";
 import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
@@ -3162,141 +3395,30 @@ export declare class MiniMapConfigManager extends Configurator<MiniMap, MiniMapC
     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 { BaseScene, Configurable, Event } from "../../Types";
 import { Components } from "../../Components";
-import { AsyncEvent, Configurable, Event, World } from "../../Types";
-import { CullerRendererConfig, CullerRendererConfigManager } from "./culler-renderer-config";
+import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
 /**
- * A base renderer to determine visibility on screen.
+ * 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 CullerRenderer implements Configurable<CullerRendererConfigManager, CullerRendererConfig> {
+export declare class SimpleScene extends BaseScene implements Configurable<SimpleSceneConfigManager, SimpleSceneConfig> {
     /** {@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;
-}
-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.
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
      */
-    set threshold(value: number);
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
+    three: THREE.Scene;
+    /** {@link Configurable.config} */
+    config: SimpleSceneConfigManager;
+    protected _defaultConfig: SimpleSceneConfig;
+    constructor(components: Components);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleSceneConfig>): void;
     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.
-     */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    /**
-     * 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}
-     */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
 }
 import * as THREE from "three";
 import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
@@ -3377,42 +3499,6 @@ export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends Base
     /** {@link Disposable.dispose} */
     dispose(disposeResources?: boolean): void;
 }
-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 { 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";
@@ -3530,68 +3616,280 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
     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);
-}
+import { Disposable, Event } from "../../Types";
 /**
- * Configuration interface for the {@link SimpleScene}.
+ * 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 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 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;
 }
-export {};
+import * as THREE from "three";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+import { Mouse } from "./mouse";
 /**
- * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
+ * A 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 Event<T> {
+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 { 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.
+ */
+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;
+}
+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 * 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.
+     */
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    /**
+     * 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}
+     */
+    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
+}
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
+/**
+ * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
+ */
+export declare class Event<T> {
     /**
      * Add a callback to this event instance.
      * @param handler - the callback to be added to this event.
@@ -3752,33 +4050,10 @@ export interface CameraControllable {
     controls: CameraControls;
 }
 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.
+ * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
  */
-export declare abstract class 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 { Base } from "./base";
-/**
- * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
- */
-export declare abstract class Component extends Base {
+export declare abstract class Component extends Base {
     /**
      * Whether this component is active or not. The behaviour can vary depending
      * on the type of component. E.g. a disabled dimension tool will stop creating
@@ -3806,6 +4081,82 @@ export declare abstract class Base {
     /** 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 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 * 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 { Vector2 } from "three";
 import { Event } from "./event";
@@ -3872,57 +4223,38 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
     setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }
 import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { BaseWorldItem } from "./base-world-item";
-import { CameraControllable } from "./interfaces";
+import { BaseScene } from "./base-scene";
+import { BaseCamera } from "./base-camera";
+import { BaseRenderer } from "./base-renderer";
+import { Updateable, Disposable } from "./interfaces";
 /**
- * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
+ * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
  */
-export declare abstract class BaseCamera extends BaseWorldItem {
+export interface World extends Disposable, Updateable {
     /**
-     * Whether the camera is enabled or not.
+     * A set of meshes present in the world. This is taken into account for operations like raycasting.
      */
-    abstract enabled: boolean;
+    meshes: Set<THREE.Mesh>;
     /**
-     * The Three.js camera instance.
+     * The base scene of the world.
      */
-    abstract three: THREE.Camera;
+    scene: BaseScene;
     /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
+     * The base camera of the world.
      */
-    abstract controls?: CameraControls;
+    camera: BaseCamera;
     /**
-     * Checks whether the instance is {@link CameraControllable}.
-     *
-     * @returns True if the instance is controllable, false otherwise.
+     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
      */
-    hasCameraControls: () => this is CameraControllable;
-}
-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>;
+    renderer: BaseRenderer | null;
     /**
-     * Abstract property representing the three.js object associated with this scene.
-     * It should be implemented by subclasses.
+     * A unique identifier for the world.
      */
-    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;
+    uuid: string;
+    /**
+     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     */
+    isDisposing: boolean;
 }
 import { Event } from "./event";
 /**
@@ -3983,53 +4315,6 @@ export declare class DataSet<T> extends Set<T> {
      */
     dispose(): void;
 }
-import * as THREE from "three";
-import { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
-/**
- * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
- */
-export interface World extends Disposable, Updateable {
-    /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
-     */
-    meshes: Set<THREE.Mesh>;
-    /**
-     * The base scene of the world.
-     */
-    scene: BaseScene;
-    /**
-     * The base camera of the world.
-     */
-    camera: BaseCamera;
-    /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
-     */
-    renderer: BaseRenderer | null;
-    /**
-     * A unique identifier for the world.
-     */
-    uuid: string;
-    /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
-     */
-    isDisposing: boolean;
-}
-import { 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 Map class and provides additional events for item set, update, delete, and clear operations.
@@ -4143,387 +4428,24 @@ export type ControlEntry = BooleanSettingsControl | ColorSettingsControl | TextS
 export interface ControlsSchema {
     [name: string]: ControlEntry | ControlsSchema;
 }
-import { SimplePlane } from "../../Clipper";
-import { DataSet } from "../../Types";
-export interface ViewpointCamera {
-    direction: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    position: {
-        x: number;
-        y: number;
-        z: number;
+import { Component } from "./component";
+export type ComponentUIElement = {
+    name: string;
+    componentID: string;
+    attributes: {
+        [name: string]: string;
     };
-    aspectRatio: number;
-}
-export interface ViewpointPerspectiveCamera extends ViewpointCamera {
-    fov: number;
-}
-export interface ViewpointOrthographicCamera extends ViewpointCamera {
-    viewToWorldScale: number;
-}
-/**
- * Represents a viewpoint in a BCF file.
- */
-export interface BCFViewpoint {
-    title?: string;
-    guid: string;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
-    selectionComponents: Iterable<string>;
-    exceptionComponents: Iterable<string>;
-    clippingPlanes: DataSet<SimplePlane>;
-    spacesVisible: boolean;
-    spaceBoundariesVisible: boolean;
-    openingsVisible: boolean;
-    defaultVisibility: boolean;
+    get: () => HTMLElement;
+};
+export declare abstract class ComponentWithUI extends Component {
+    abstract name: string;
+    abstract getUI(): ComponentUIElement[];
 }
 import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { BCFViewpoint, ViewpointOrthographicCamera, ViewpointPerspectiveCamera } from "./types";
-import { CameraProjection } from "../../OrthoPerspectiveCamera";
+import { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
-import { DataMap, DataSet, World } from "../../Types";
-import { SimplePlane } from "../../Clipper";
 /**
- * Represents a BCF compliant viewpoint from BuildingSMART.
- *
- * The Viewpoint class provides methods for managing and interacting with viewpoints.
- * It includes functionality for setting viewpoint properties, updating the camera,
- * applying color to components, and serializing the viewpoint for export.
- */
-export declare class Viewpoint implements BCFViewpoint {
-    title?: string;
-    readonly guid: string;
-    /**
-     * ClippingPlanes can be used to define a subsection of a building model that is related to the topic.
-     * Each clipping plane is defined by Location and Direction.
-     * The Direction vector points in the invisible direction meaning the half-space that is clipped.
-     * @experimental
-     */
-    clippingPlanes: DataSet<SimplePlane>;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
-    /**
-     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
-     */
-    readonly exceptionComponents: DataSet<string>;
-    /**
-     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
-     */
-    readonly selectionComponents: DataSet<string>;
-    /**
-     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
-     * For this to work, call viewpoint.colorize()
-     */
-    readonly componentColors: DataMap<THREE.Color, string[]>;
-    /**
-     * Boolean flags to allow fine control over the visibility of spaces.
-     * A typical use of these flags is when DefaultVisibility=true but spaces should remain hidden.
-     * @default false
-     */
-    spacesVisible: boolean;
-    /**
-     * Boolean flags to allow fine control over the visibility of space boundaries.
-     * A typical use of these flags is when DefaultVisibility=true but space boundaries should remain hidden.
-     * @default false
-     */
-    spaceBoundariesVisible: boolean;
-    /**
-     * Boolean flags to allow fine control over the visibility of openings.
-     * A typical use of these flags is when DefaultVisibility=true but openings should remain hidden.
-     * @default false
-     */
-    openingsVisible: boolean;
-    /**
-     * When true, all components should be visible unless listed in the exceptions
-     * When false all components should be invisible unless listed in the exceptions
-     */
-    defaultVisibility: boolean;
-    private get _selectionModelIdMap();
-    private get _exceptionModelIdMap();
-    /**
-     * A list of components that should be selected (highlighted) when displaying a viewpoint.
-     * @returns The fragmentIdMap for components marked as selections.
-     */
-    get selection(): FRAGS.FragmentIdMap;
-    /**
-     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
-     * @returns The fragmentIdMap for components marked as exceptions.
-     */
-    get exception(): FRAGS.FragmentIdMap;
-    /**
-     * Retrieves the projection type of the viewpoint's camera.
-     *
-     * @returns A string representing the projection type of the viewpoint's camera.
-     *          It can be either 'Perspective' or 'Orthographic'.
-     */
-    get projection(): CameraProjection;
-    /**
-     * Retrieves the position vector of the viewpoint's camera.
-     *
-     * @remarks
-     * The position vector represents the camera's position in the world coordinate system.
-     * The function applies the base coordinate system transformation to the position vector.
-     *
-     * @returns A THREE.Vector3 representing the position of the viewpoint's camera.
-     */
-    get position(): THREE.Vector3;
-    /**
-     * Retrieves the direction vector of the viewpoint's camera.
-     *
-     * @remarks
-     * The direction vector represents the direction in which the camera is pointing.
-     * It is calculated by extracting the x, y, and z components from the camera's direction property.
-     *
-     * @returns A THREE.Vector3 representing the direction of the viewpoint's camera.
-     */
-    get direction(): THREE.Vector3;
-    private _components;
-    /**
-     * Represents the world in which the viewpoints are created and managed.
-     */
-    readonly world: World;
-    private get _managerVersion();
-    /**
-     * Retrieves the list of BCF topics associated with the current viewpoint.
-     *
-     * @remarks
-     * This function retrieves the BCFTopics manager from the components,
-     * then filters the list of topics to find those associated with the current viewpoint.
-     *
-     * @returns An array of BCF topics associated with the current viewpoint.
-     */
-    get topics(): import("../../../openbim/BCFTopics").Topic[];
-    constructor(components: Components, world: World, _config?: {
-        data?: Partial<BCFViewpoint>;
-        setCamera?: boolean;
-    });
-    /**
-     * Adds components to the viewpoint based on the provided fragment ID map.
-     *
-     * @param fragmentIdMap - A map containing fragment IDs as keys and arrays of express IDs as values.
-     */
-    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
-    /**
-     * Replace the properties of the viewpoint with the provided data.
-     *
-     * @remarks The guid will be ommited as it shouldn't change after it has been initially set.
-     * @remarks The existing selection and exception components will be fully replaced in case new ones are provided.
-     *
-     * @param data - An object containing the properties to be set.
-     *               The properties not included in the object will remain unchanged.
-     *
-     * @returns The viewpoint instance with the updated properties.
-     */
-    set(data: Partial<BCFViewpoint>): this;
-    /**
-     * Sets the viewpoint of the camera in the world.
-     *
-     * @remarks
-     * This function calculates the target position based on the viewpoint information.
-     * It sets the visibility of the viewpoint components and then applies the viewpoint using the camera's controls.
-     *
-     * @param transition - Indicates whether the camera movement should have a transition effect.
-     *                      Default value is 'true'.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     *
-     * @returns A Promise that resolves when the camera has been set.
-     */
-    go(transition?: boolean): Promise<void>;
-    /**
-     * Updates the camera settings of the viewpoint based on the current world's camera and renderer.
-     *
-     * @remarks
-     * This function retrieves the camera's position, direction, and aspect ratio from the world's camera and renderer.
-     * It then calculates the camera's perspective or orthographic settings based on the camera type.
-     * Finally, it updates the viewpoint's camera settings and updates the viewpoint to the Viewpoints manager.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
-     */
-    updateCamera(): void;
-    applyVisibility(): void;
-    /**
-     * Applies color to the components in the viewpoint based on their GUIDs.
-     *
-     * This function iterates through the 'componentColors' map, retrieves the fragment IDs
-     * corresponding to each color, and then uses the 'Classifier' to apply the color to those fragments.
-     *
-     * @remarks
-     * The color is applied using the 'Classifier.setColor' method, which sets the color of the specified fragments.
-     * The color is provided as a hexadecimal string, prefixed with a '#'.
-     */
-    applyColors(): void;
-    /**
-     * Resets the colors of all components in the viewpoint to their original color.
-     */
-    resetColors(): void;
-    private createComponentTags;
-    private createColorTags;
-    /**
-     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
-     *
-     * @param version - The version of the BCF Manager to use for serialization.
-     *                   If not provided, the current version of the manager will be used.
-     *
-     * @returns A Promise that resolves to an XML string representing the viewpoint.
-     *          The XML string follows the BCF VisualizationInfo schema.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
-     */
-    serialize(version?: string): Promise<string>;
-}
-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 { 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 { Hideable, Disposable, Event, World } from "../../Types";
-import { Components } from "../../Components";
-/**
- * Each of the clipping planes created by the clipper.
+ * Each of the clipping planes created by the clipper.
  */
 export declare class SimplePlane implements Disposable, Hideable {
     /** Event that fires when the user starts dragging a clipping plane. */
@@ -4634,6 +4556,73 @@ export declare class FirstPersonMode implements NavigationMode {
     set(active: boolean): void;
     private setupFirstPersonCamera;
 }
+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";
 /**
@@ -4715,11 +4704,6 @@ export declare class ProjectionManager {
     private getDistance;
     private setPerspectiveCamera;
 }
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-}
 /**
  * The projection system of the camera.
  */
@@ -4746,172 +4730,229 @@ export interface NavigationMode {
     /** Whether this navigation mode is active or not. */
     enabled: boolean;
 }
-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 * 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;
-}
 /**
- * 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.
+ * A rule for the {@link IfcFinder} to search items based on their category.
  */
-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 IfcCategoryRule {
+    /**
+     * The type of this rule. All rules have a fixed type.
+     */
+    type: "category";
+    /**
+     * The category value. It's a regular expression, so you can make complex queries and use ".*" to match all categories.
+     */
+    value: RegExp;
 }
 /**
- * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
+ * A rule for the {@link IfcFinder} to search items based on the properties defined in their property sets.
  */
-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 interface IfcPropertyRule {
+    /**
+     * The type of this rule. All rules have a fixed type.
+     */
+    type: "property";
+    /**
+     * The name of the property. It's a regular expression, so you can make complex queries and use ".*" to match all names.
+     */
+    name: RegExp;
+    /**
+     * The value of the property. It's a regular expression, so you can make complex queries and use ".*" to match all values.
+     */
+    value: RegExp;
 }
-import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
- * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
+ * A rule for the {@link IfcFinder} to search items based on the value of a numeric property defined in their property sets.
  */
-export declare class IfcStreamingSettings extends IfcFragmentSettings {
+export interface IfcOperatorRule {
     /**
-     * Minimum number of geometries to be streamed.
-     * Defaults to 10 geometries.
+     * The type of this rule. All rules have a fixed type.
      */
-    minGeometrySize: number;
+    type: "operator";
     /**
-     * Minimum amount of assets to be streamed.
-     * Defaults to 1000 assets.
+     * The name of the property. It's a regular expression, so you can make complex queries and use ".*" to match all names.
      */
-    minAssetsSize: number;
+    name: RegExp;
     /**
-     * Maximum amount of triangles per fragment. Useful for controlling the maximum size of fragment files.
+     * The value of the property.
      */
-    maxTriangles: number | null;
+    value: number;
+    /**
+     * The operator to apply to the numeric value.
+     */
+    operator: "<" | ">" | "=" | "<=" | ">=";
 }
 /**
- * A rule for the {@link IfcFinder} to search items based on their category.
+ * The type of rules that can be used in the queries of the {@link IfcFinder}.
  */
-export interface IfcCategoryRule {
+export type IfcFinderRule = IfcCategoryRule | IfcPropertyRule | IfcOperatorRule;
+/**
+ * The data type used when the queries of the {@link IfcFinder} export or import query data to persist it.
+ */
+export type SerializedQuery = {
     /**
-     * The type of this rule. All rules have a fixed type.
+     * {@link IfcFinderQuery.name}
      */
-    type: "category";
+    name: string;
     /**
-     * The category value. It's a regular expression, so you can make complex queries and use ".*" to match all categories.
+     * {@link IfcFinderQuery.inclusive}
      */
-    value: RegExp;
-}
+    inclusive: boolean;
+    /**
+     * The type of query.
+     */
+    type: string;
+    /**
+     * {@link IfcFinderQuery.ids}
+     */
+    ids: {
+        [modelID: string]: number[];
+    };
+    /**
+     * {@link IfcFinderQuery.rules}
+     */
+    rules: {
+        [key: string]: any;
+    }[];
+};
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFinderRule, SerializedQuery } from "./types";
+import { Components, Event } from "../../../core";
 /**
- * A rule for the {@link IfcFinder} to search items based on the properties defined in their property sets.
+ * The base class for all queries used by the {@link IfcFinder}.
  */
-export interface IfcPropertyRule {
+export declare abstract class IfcFinderQuery {
+    /**
+     * The list of functions to import the queries. If you create your own custom query, you should add its importer here. See the other queries provided by the library for reference.
+     */
+    static importers: Map<string, (components: Components, data: any) => IfcFinderQuery>;
+    /**
+     * Event used to notify the progress when performing a query on an IFC file.
+     */
+    readonly onProgress: Event<number>;
+    /**
+     * A name given to the instance of the query to identify it.
+     */
+    abstract name: string;
+    /**
+     * The list of IFC items that this query found across all models.
+     */
+    abstract items: FRAGS.FragmentIdMap;
+    /**
+     * If false, ALL rules of the query must comply to make a match. If true, ANY rule will be enough to make a match.
+     */
+    inclusive: boolean;
+    /**
+     * The list of rules to be applied by this query.
+     */
+    rules: IfcFinderRule[];
+    /**
+     * The IDs of the match items per model.
+     */
+    ids: {
+        [modelID: string]: Set<number>;
+    };
     /**
-     * The type of this rule. All rules have a fixed type.
+     * Whether this query is up to date or not per file. If not, when updating the group where it belongs, it will re-process the given file.
      */
-    type: "property";
+    needsUpdate: Map<string, boolean>;
     /**
-     * The name of the property. It's a regular expression, so you can make complex queries and use ".*" to match all names.
+     * Export the current data of this query in a serializable object to persist it over time.
      */
-    name: RegExp;
+    abstract export(): {
+        [key: string]: any;
+    };
     /**
-     * The value of the property. It's a regular expression, so you can make complex queries and use ".*" to match all values.
+     * Perform the search in the given file and save the result.
      */
-    value: RegExp;
-}
-/**
- * A rule for the {@link IfcFinder} to search items based on the value of a numeric property defined in their property sets.
- */
-export interface IfcOperatorRule {
+    abstract update(modelID: string, file: File): Promise<void>;
+    protected components: Components;
+    protected abstract findInLines(modelID: string, lines: string[]): void;
+    protected constructor(components: Components);
     /**
-     * The type of this rule. All rules have a fixed type.
+     * Imports a query given its data. This data can be generating using its {@link IfcFinderQuery.export} method.
+     *
+     * @param components the instance of {@link Components} used by this app.
+     * @param data the data of the query to import as a serializable object.
      */
-    type: "operator";
+    static import(components: Components, data: {
+        [id: string]: any;
+    }): IfcFinderQuery | null;
     /**
-     * The name of the property. It's a regular expression, so you can make complex queries and use ".*" to match all names.
+     * Imports the given serialized rules. Only use this when writing your own custom query. See the other queries provided by the library for reference.
+     *
+     * @param serializedRules the rules to be parsed.
      */
-    name: RegExp;
+    static importRules(serializedRules: {
+        [key: string]: any;
+    }[]): IfcFinderRule[];
     /**
-     * The value of the property.
+     * Imports the given IDs. Only use this when writing your own custom query. See the other queries provided by the library for reference.
+     *
+     * @param data the serialized object representing the query whose IDs to parse.
      */
-    value: number;
+    static importIds(data: SerializedQuery): {
+        [modelID: string]: Set<number>;
+    };
     /**
-     * The operator to apply to the numeric value.
+     * Clears the data of the given model. If not specified, clears all the data.
+     *
+     * @param modelID ID of the model whose data to clear.
      */
-    operator: "<" | ">" | "=" | "<=" | ">=";
+    clear(modelID?: string): void;
+    protected addID(modelID: string, id: number): void;
+    protected getData(): SerializedQuery;
+    protected exportRules(): {
+        [key: string]: any;
+    }[];
+    protected findInFile(modelID: string, file: File): Promise<void>;
+    protected getIdFromLine(line: string): number;
+    protected testRules(line: string): boolean;
+    protected getCategoryFromLine(line: string): string | null;
+    protected getAttributesFromLine(line: string): string[] | null;
 }
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFinderRule, SerializedQuery } from "./types";
+import { IfcFinderQuery } from "./ifc-finder-query";
+import { Components } from "../../../core";
 /**
- * The type of rules that can be used in the queries of the {@link IfcFinder}.
- */
-export type IfcFinderRule = IfcCategoryRule | IfcPropertyRule | IfcOperatorRule;
-/**
- * The data type used when the queries of the {@link IfcFinder} export or import query data to persist it.
+ * A query that checks the direct attributes of IFC items.
  */
-export type SerializedQuery = {
+export declare class IfcBasicQuery extends IfcFinderQuery {
     /**
      * {@link IfcFinderQuery.name}
      */
     name: string;
     /**
-     * {@link IfcFinderQuery.inclusive}
+     * The type of this query.
      */
-    inclusive: boolean;
+    static type: "IfcBasicQuery";
     /**
-     * The type of query.
+     * {@link IfcFinderQuery.items}
      */
-    type: string;
+    get items(): FRAGS.FragmentIdMap;
+    constructor(components: Components, data: {
+        name: string;
+        rules: IfcFinderRule[];
+        inclusive: boolean;
+    });
     /**
-     * {@link IfcFinderQuery.ids}
+     * {@link IfcFinderQuery.export}
      */
-    ids: {
-        [modelID: string]: number[];
-    };
+    export(): SerializedQuery;
     /**
-     * {@link IfcFinderQuery.rules}
+     * {@link IfcFinderQuery.update}
      */
-    rules: {
-        [key: string]: any;
-    }[];
-};
+    update(modelID: string, file: File): Promise<void>;
+    protected findInLines(modelID: string, lines: string[]): void;
+}
 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}
      */
@@ -4919,15 +4960,16 @@ 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;
+        rules: (IfcPropertyRule | IfcOperatorRule)[];
     });
     /**
      * {@link IfcFinderQuery.export}
@@ -4939,102 +4981,299 @@ export declare class IfcBasicQuery extends IfcFinderQuery {
     update(modelID: string, file: File): Promise<void>;
     protected findInLines(modelID: string, lines: string[]): void;
 }
+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 { 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 * as WEBIFC from "web-ifc";
+export declare class IfcMetadataReader {
+    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+}
+/**
+ * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
+ */
+export interface StreamedGeometries {
+    [id: number]: {
+        /** The bounding box of the geometry as a Float32Array. */
+        boundingBox: Float32Array;
+        /** A boolean indicating whether the geometry has holes. */
+        hasHoles: boolean;
+        /** An optional file path for the geometry data. */
+        geometryFile?: string;
+    };
+}
+/**
+ * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
+ */
+export interface StreamedAsset {
+    /** The unique identifier of the asset. */
+    id: number;
+    /** An array of geometries associated with the asset. */
+    geometries: {
+        /** The unique identifier of the geometry. */
+        geometryID: number;
+        /** The transformation matrix of the geometry as a number array. */
+        transformation: number[];
+        /** The color of the geometry as a number array. */
+        color: number[];
+    }[];
+}
+import * as 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;
+};
+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;
+}
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createEntityFacets: (components: Components, elements: any) => IDSFacet[];
 import * as FRAGS from "@thatopen/fragments";
-import { IfcFinderRule, SerializedQuery } from "./types";
-import { Components, Event } from "../../../core";
+import { Components } from "../../../core/Components";
+import { DataSet } from "../../../core/Types";
+import { IDSCheckResult, IfcVersion } from "./types";
+import { IDSFacet } from "./facets";
 /**
- * The base class for all queries used by the {@link IfcFinder}.
+ * 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 abstract class IfcFinderQuery {
-    /**
-     * The list of functions to import the queries. If you create your own custom query, you should add its importer here. See the other queries provided by the library for reference.
-     */
-    static importers: Map<string, (components: Components, data: any) => IfcFinderQuery>;
-    /**
-     * Event used to notify the progress when performing a query on an IFC file.
-     */
-    readonly onProgress: Event<number>;
-    /**
-     * A name given to the instance of the query to identify it.
-     */
-    abstract name: string;
-    /**
-     * The list of IFC items that this query found across all models.
-     */
-    abstract items: FRAGS.FragmentIdMap;
-    /**
-     * If false, ALL rules of the query must comply to make a match. If true, ANY rule will be enough to make a match.
-     */
-    inclusive: boolean;
-    /**
-     * The list of rules to be applied by this query.
-     */
-    rules: IfcFinderRule[];
-    /**
-     * The IDs of the match items per model.
-     */
-    ids: {
-        [modelID: string]: Set<number>;
-    };
-    /**
-     * Whether this query is up to date or not per file. If not, when updating the group where it belongs, it will re-process the given file.
-     */
-    needsUpdate: Map<string, boolean>;
-    /**
-     * Export the current data of this query in a serializable object to persist it over time.
-     */
-    abstract export(): {
-        [key: string]: any;
-    };
-    /**
-     * Perform the search in the given file and save the result.
-     */
-    abstract update(modelID: string, file: File): Promise<void>;
+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;
-    protected abstract findInLines(modelID: string, lines: string[]): void;
-    protected constructor(components: Components);
-    /**
-     * Imports a query given its data. This data can be generating using its {@link IfcFinderQuery.export} method.
-     *
-     * @param components the instance of {@link Components} used by this app.
-     * @param data the data of the query to import as a serializable object.
-     */
-    static import(components: Components, data: {
-        [id: string]: any;
-    }): IfcFinderQuery | null;
+    constructor(components: Components, name: string, ifcVersion: IfcVersion[]);
     /**
-     * Imports the given serialized rules. Only use this when writing your own custom query. See the other queries provided by the library for reference.
+     * Tests the model to test against the specification's requirements.
      *
-     * @param serializedRules the rules to be parsed.
+     * @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.
      */
-    static importRules(serializedRules: {
-        [key: string]: any;
-    }[]): IfcFinderRule[];
+    test(model: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
     /**
-     * Imports the given IDs. Only use this when writing your own custom query. See the other queries provided by the library for reference.
+     * Serializes the IDSSpecification instance into XML format.
      *
-     * @param data the serialized object representing the query whose IDs to parse.
-     */
-    static importIds(data: SerializedQuery): {
-        [modelID: string]: Set<number>;
-    };
-    /**
-     * Clears the data of the given model. If not specified, clears all the data.
+     * @remarks This method is not meant to be used directly. It is used by the IDSSpecifications component.
      *
-     * @param modelID ID of the model whose data to clear.
+     * @returns The XML representation of the IDSSpecification.
      */
-    clear(modelID?: string): void;
-    protected addID(modelID: string, id: number): void;
-    protected getData(): SerializedQuery;
-    protected exportRules(): {
-        [key: string]: any;
-    }[];
-    protected findInFile(modelID: string, file: File): Promise<void>;
-    protected getIdFromLine(line: string): number;
-    protected testRules(line: string): boolean;
-    protected getCategoryFromLine(line: string): string | null;
-    protected getAttributesFromLine(line: string): string[] | null;
+    serialize(): string;
+}
+import { IDSFacetParameter } from "../types";
+export declare const getParameterValue: (property: any) => IDSFacetParameter | undefined;
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createClassificationFacets: (components: Components, elements: any) => IDSFacet[];
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createAttributeFacets: (components: Components, elements: any) => IDSFacet[];
+import * as WEBIFC from "web-ifc";
+export type RelationsMap = Map<number, Map<number, number[]>>;
+export interface ModelsRelationMap {
+    [modelID: string]: RelationsMap;
+}
+/**
+ * Type alias for an array of inverse attribute names.
+ */
+export type InverseAttributes = [
+    "IsDecomposedBy",
+    "Decomposes",
+    "AssociatedTo",
+    "HasAssociations",
+    "ClassificationForObjects",
+    "IsGroupedBy",
+    "HasAssignments",
+    "IsDefinedBy",
+    "DefinesOcurrence",
+    "IsTypedBy",
+    "Types",
+    "Defines",
+    "ContainedInStructure",
+    "ContainsElements",
+    "HasControlElements",
+    "AssignedToFlowElement",
+    "ConnectedTo",
+    "ConnectedFrom",
+    "ReferencedBy",
+    "Declares",
+    "HasContext",
+    "Controls",
+    "IsNestedBy",
+    "Nests",
+    "DocumentRefForObjects"
+];
+export type InverseAttribute = InverseAttributes[number];
+/**
+ * Type alias for an array of IfcRelation types from WebIfc.
+ */
+export type IfcRelations = [
+    typeof WEBIFC.IFCRELAGGREGATES,
+    typeof WEBIFC.IFCRELASSOCIATESMATERIAL,
+    typeof WEBIFC.IFCRELASSOCIATESCLASSIFICATION,
+    typeof WEBIFC.IFCRELASSIGNSTOGROUP,
+    typeof WEBIFC.IFCRELDEFINESBYPROPERTIES,
+    typeof WEBIFC.IFCRELDEFINESBYTYPE,
+    typeof WEBIFC.IFCRELDEFINESBYTEMPLATE,
+    typeof WEBIFC.IFCRELCONTAINEDINSPATIALSTRUCTURE,
+    typeof WEBIFC.IFCRELFLOWCONTROLELEMENTS,
+    typeof WEBIFC.IFCRELCONNECTSELEMENTS,
+    typeof WEBIFC.IFCRELASSIGNSTOPRODUCT,
+    typeof WEBIFC.IFCRELDECLARES,
+    typeof WEBIFC.IFCRELASSIGNSTOCONTROL,
+    typeof WEBIFC.IFCRELNESTS,
+    typeof WEBIFC.IFCRELASSOCIATESDOCUMENT
+];
+export type IfcRelation = IfcRelations[number];
+export interface RelationsProcessingConfig {
+    relationsToProcess: IfcRelation[];
+}
+/**
+ * Interface definition of an Entities Related Event from the IfcRelationsIndexer.
+ * This event gets triggered when two or more entities has been related with each other.
+ */
+export interface EntitiesRelatedEvent {
+    /** The type of the IFC relation. */
+    relType: IfcRelation;
+    /** The inverse attribute of the relation. */
+    invAttribute: InverseAttribute;
+    /** The IDs of the entities that are relating. */
+    relatingIDs: number[];
+    /** The IDs of the entities that are being related. */
+    relatedIDs: number[];
 }
+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 = [
+    "IfcRelAssignsToControl",
+    "IfcRelAssignsToGroup",
+    "IfcRelAssignsToProduct",
+    "IfcRelAssociatesClassification",
+    "IfcRelAssociatesMaterial",
+    "IfcRelAssociatesDocument",
+    "IfcRelContainedInSpatialStructure",
+    "IfcRelFlowControlElements",
+    "IfcRelConnectsElements",
+    "IfcRelDeclares",
+    "IfcRelAggregates",
+    "IfcRelNests",
+    "IfcRelDefinesByProperties",
+    "IfcRelDefinesByType",
+    "IfcRelDefinesByTemplate"
+];
+export type IfcRelName = IfcRelationNames[number];
 export type BCFVersion = "2.1" | "3";
 export interface BCFTopic {
     guid: string;
@@ -5054,42 +5293,6 @@ export interface BCFTopic {
     description?: string;
     stage?: string;
 }
-import * as FRAGS from "@thatopen/fragments";
-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.
- */
-export declare class IfcPropertyQuery extends IfcFinderQuery {
-    /**
-     * {@link IfcFinderQuery.name}
-     */
-    name: string;
-    /**
-     * The type of this query.
-     */
-    static type: "IfcPropertyQuery";
-    private psets;
-    /**
-     * {@link IfcFinderQuery.items}
-     */
-    get items(): FRAGS.FragmentIdMap;
-    constructor(components: Components, data: {
-        name: string;
-        inclusive: boolean;
-        rules: (IfcPropertyRule | IfcOperatorRule)[];
-    });
-    /**
-     * {@link IfcFinderQuery.export}
-     */
-    export(): SerializedQuery;
-    /**
-     * {@link IfcFinderQuery.update}
-     */
-    update(modelID: string, file: File): Promise<void>;
-    protected findInLines(modelID: string, lines: string[]): void;
-}
 import { Components } from "../../../core/Components";
 import { Viewpoint } from "../../../core/Viewpoints";
 import { Comment } from "./Comment";
@@ -5253,13 +5456,6 @@ export declare class Comment {
      */
     serialize(): string;
 }
-import { IfcRelName } from "./types";
-type IfcRelAttributePosition = {
-    related: number;
-    relating: number;
-};
-export declare const ifcRelAttrsPosition: Record<IfcRelName, IfcRelAttributePosition>;
-export {};
 import { BCFTopics, BCFVersion } from "../index";
 import { BooleanSettingsControl, Configurator, SelectSettingControl, TextSetSettingControl, TextSettingsControl } from "../../../core";
 /**
@@ -5382,196 +5578,6 @@ export declare class BCFTopicsConfigManager extends Configurator<BCFTopics, BCFT
     set ignoreIncompleteTopicsOnImport(value: boolean);
 }
 export {};
-import { IfcRelName } from "./types";
-import { IfcRelation } from "../../IfcRelationsIndexer";
-export declare const ifcRelClassNames: Record<IfcRelation, IfcRelName>;
-export type IfcRelationNames = [
-    "IfcRelAssignsToControl",
-    "IfcRelAssignsToGroup",
-    "IfcRelAssignsToProduct",
-    "IfcRelAssociatesClassification",
-    "IfcRelAssociatesMaterial",
-    "IfcRelAssociatesDocument",
-    "IfcRelContainedInSpatialStructure",
-    "IfcRelFlowControlElements",
-    "IfcRelConnectsElements",
-    "IfcRelDeclares",
-    "IfcRelAggregates",
-    "IfcRelNests",
-    "IfcRelDefinesByProperties",
-    "IfcRelDefinesByType",
-    "IfcRelDefinesByTemplate"
-];
-export type IfcRelName = IfcRelationNames[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 createClassificationFacets: (components: Components, elements: any) => IDSFacet[];
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "../facets";
-export declare const createAttributeFacets: (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;
-}
-/**
- * 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;
-}
-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 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.
-     */
-    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;
-}
-import { IDSFacetParameter } from "../types";
-export declare const getParameterValue: (property: any) => IDSFacetParameter | undefined;
-import * as WEBIFC from "web-ifc";
-export type RelationsMap = Map<number, Map<number, number[]>>;
-export interface ModelsRelationMap {
-    [modelID: string]: RelationsMap;
-}
-/**
- * Type alias for an array of inverse attribute names.
- */
-export type InverseAttributes = [
-    "IsDecomposedBy",
-    "Decomposes",
-    "AssociatedTo",
-    "HasAssociations",
-    "ClassificationForObjects",
-    "IsGroupedBy",
-    "HasAssignments",
-    "IsDefinedBy",
-    "DefinesOcurrence",
-    "IsTypedBy",
-    "Types",
-    "Defines",
-    "ContainedInStructure",
-    "ContainsElements",
-    "HasControlElements",
-    "AssignedToFlowElement",
-    "ConnectedTo",
-    "ConnectedFrom",
-    "ReferencedBy",
-    "Declares",
-    "HasContext",
-    "Controls",
-    "IsNestedBy",
-    "Nests",
-    "DocumentRefForObjects"
-];
-export type InverseAttribute = InverseAttributes[number];
-/**
- * Type alias for an array of IfcRelation types from WebIfc.
- */
-export type IfcRelations = [
-    typeof WEBIFC.IFCRELAGGREGATES,
-    typeof WEBIFC.IFCRELASSOCIATESMATERIAL,
-    typeof WEBIFC.IFCRELASSOCIATESCLASSIFICATION,
-    typeof WEBIFC.IFCRELASSIGNSTOGROUP,
-    typeof WEBIFC.IFCRELDEFINESBYPROPERTIES,
-    typeof WEBIFC.IFCRELDEFINESBYTYPE,
-    typeof WEBIFC.IFCRELDEFINESBYTEMPLATE,
-    typeof WEBIFC.IFCRELCONTAINEDINSPATIALSTRUCTURE,
-    typeof WEBIFC.IFCRELFLOWCONTROLELEMENTS,
-    typeof WEBIFC.IFCRELCONNECTSELEMENTS,
-    typeof WEBIFC.IFCRELASSIGNSTOPRODUCT,
-    typeof WEBIFC.IFCRELDECLARES,
-    typeof WEBIFC.IFCRELASSIGNSTOCONTROL,
-    typeof WEBIFC.IFCRELNESTS,
-    typeof WEBIFC.IFCRELASSOCIATESDOCUMENT
-];
-export type IfcRelation = IfcRelations[number];
 import { BooleanSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
 import { CullerRenderer } from "../index";
@@ -5646,8 +5652,6 @@ export declare class CullerRendererConfigManager extends Configurator<CullerRend
     private resetInterval;
 }
 export {};
-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";
@@ -5662,6 +5666,31 @@ export declare class IDSAttribute extends IDSFacet {
 }
 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 * 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 {
@@ -5718,36 +5747,64 @@ export declare class IDSProperty extends IDSFacet {
     private evalDataType;
     private evalURI;
 }
-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 { BCFTopics } from "../..";
+export declare const extensionsImporter: (manager: BCFTopics, extensionsXML: string) => void;
 import { BufferGeometry } from "three";
 import * as THREE from "three";
 export declare class TransformHelper {
     getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
 }
+declare const actual: {
+    186: {
+        7: number[];
+    };
+    250: {
+        8: number[];
+    };
+    253: {
+        8: number[];
+    };
+    257: {
+        8: number[];
+    };
+};
+declare const newVersion: {
+    186: {
+        7: ({
+            259: number[];
+            263?: undefined;
+            266?: undefined;
+        } | {
+            263: number[];
+            259?: undefined;
+            266?: undefined;
+        } | {
+            266: number[];
+            259?: undefined;
+            263?: undefined;
+        })[];
+    };
+    190: {
+        7: {
+            259: number[];
+        }[];
+    };
+    250: {
+        8: {
+            259: number[];
+        }[];
+    };
+};
+interface V2Schema {
+    [expressID: number]: {
+        [invAttrIndex: number]: {
+            [IfcRelationship: number]: number[];
+        };
+    };
+}
+type RelationsMap = Map<number, Map<number, {
+    [ifcRel: number]: number[];
+}>>;
 import { IDSFacetParameter } from "../types";
 import { IDSFacet } from "./Facet";
 export declare class IdsMaterialFacet extends IDSFacet {