@thatopen/components 2.3.15 → 2.3.16

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.15";
+    static readonly release = "2.3.16";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
     /**
@@ -195,66 +195,6 @@ export declare class ShadowedScene extends SimpleScene implements Disposable, Co
     updateShadows(): Promise<void>;
     private recomputeShadows;
 }
-import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer, DataMap } from "../Types";
-import { Components } from "../Components";
-import { SimpleWorld } from "./src";
-/**
- * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
- */
-export declare class Worlds extends Component implements Updateable, Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * A collection of worlds managed by this component.
-     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
-     */
-    list: DataMap<string, World>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
-     *
-     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
-     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
-     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
-     *
-     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
-     */
-    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
-    /**
-     * Deletes a world from the list of worlds.
-     *
-     * @param {World} world - The world to be deleted.
-     *
-     * @throws {Error} - Throws an error if the provided world is not found in the list.
-     */
-    delete(world: World): void;
-    /**
-     * Disposes of the Worlds component and all its managed worlds.
-     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
-     * and triggers the onDisposed event.
-     */
-    dispose(): void;
-    /** {@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";
@@ -297,17 +237,6 @@ export declare class Raycasters extends Component implements Disposable {
     /** {@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";
@@ -353,60 +282,58 @@ export declare class Grids extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import * as THREE from "three";
+import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer, DataMap } from "../Types";
 import { Components } from "../Components";
-import { MeshCullerRenderer } from "./src";
-import { Component, Event, Disposable, World } from "../Types";
+import { SimpleWorld } from "./src";
 /**
- * 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 class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
  */
-export declare class Cullers extends Component implements Disposable {
+export declare class Worlds extends Component implements Updateable, Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
-    /**
-     * An event that is triggered when the Cullers component is disposed.
-     */
+    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    private _enabled;
     /**
-     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
+     * A collection of worlds managed by this component.
+     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
      */
-    list: Map<string, MeshCullerRenderer>;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
+    list: DataMap<string, World>;
     /** {@link Component.enabled} */
-    set enabled(value: boolean);
+    enabled: 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.
+     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
      *
-     * @param world - The world for which to create the MeshCullerRenderer.
+     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
+     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
+     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
      *
-     * @returns The newly created or existing MeshCullerRenderer for the given world.
+     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
      */
-    create(world: World): MeshCullerRenderer;
+    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
     /**
-     * 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.
+     * Deletes a world from the list of worlds.
      *
-     * @param world - The world for which to delete the MeshCullerRenderer.
+     * @param {World} world - The world to be deleted.
      *
-     * @returns {void}
+     * @throws {Error} - Throws an error if the provided world is not found in the list.
      */
     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.
-     *
+     * Disposes of the Worlds component and all its managed worlds.
+     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
+     * and triggers the onDisposed event.
      */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(delta?: number): void | Promise<void>;
 }
 import * as THREE from "three";
 import { Component, Configurable, Createable, Disposable, Event, Hideable, World } from "../Types";
@@ -549,6 +476,61 @@ export declare class Clipper extends Component implements Createable, Disposable
     private _onStartDragging;
     private _onEndDragging;
 }
+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 { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
 import { Components } from "../Components";
 import { BCFViewpoint, Viewpoint } from "./src";
@@ -656,184 +638,109 @@ export declare class ConfigManager extends Component {
     constructor(components: Components);
 }
 import * as THREE from "three";
-import { Components } from "../Components";
-import { SimpleCamera } from "..";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components } from "../../core";
 /**
- * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
+ * Represents an edge measurement result.
  */
-export declare class OrthoPerspectiveCamera extends SimpleCamera {
+export interface MeasureEdge {
     /**
-     * A ProjectionManager instance that manages the projection modes of the camera.
+     * The distance between the two points of the edge.
      */
-    readonly projection: ProjectionManager;
+    distance: number;
     /**
-     * A THREE.OrthographicCamera instance that represents the orthographic camera.
-     * This camera is used when the projection mode is set to orthographic.
+     * The two points that define the edge.
      */
-    readonly threeOrtho: THREE.OrthographicCamera;
+    points: THREE.Vector3[];
+}
+/**
+ * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
+ */
+export declare class MeasurementUtils extends Component {
     /**
-     * A THREE.PerspectiveCamera instance that represents the perspective camera.
-     * This camera is used when the projection mode is set to perspective.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    readonly threePersp: THREE.PerspectiveCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    protected _mode: NavigationMode | null;
-    private previousSize;
+    static uuid: string;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
     /**
-     * Getter for the current navigation mode.
-     * Throws an error if the mode is not found or the camera is not initialized.
-     *
-     * @returns {NavigationMode} The current navigation mode.
+     * Utility method to calculate the distance from a point to a line segment.
      *
-     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
+     * @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.
      */
-    get mode(): NavigationMode;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
     /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
+     * 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 mode - The {@link NavigationMode} to set.
+     * @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.
      */
-    set(mode: NavModeID): void;
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
     /**
-     * Make the camera view fit all the specified meshes.
+     * Method to get the vertices and normal of a mesh face at a given index.
+     * It also applies instance transformation if provided.
      *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
-     */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
-    /**
-     * Allows or prevents all user input.
-     *
-     * @param active - whether to enable or disable user inputs.
-     */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
-}
-import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
-/**
- * Configuration interface for the VertexPicker component.
- */
-export interface VertexPickerConfig {
-    /**
-     * If true, only vertices will be picked, not the closest point on the face.
-     */
-    showOnlyVertex: boolean;
-    /**
-     * The maximum distance for snapping to a vertex.
-     */
-    snapDistance: number;
-    /**
-     * The HTML element to use for previewing the picked vertex.
-     */
-    previewElement: HTMLElement;
-}
-/**
- * A class that provides functionality for picking vertices in a 3D scene.
- */
-export declare class VertexPicker extends Component implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a vertex is found.
-     * The event passes a THREE.Vector3 representing the position of the found vertex.
-     */
-    readonly onVertexFound: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
-     */
-    readonly onVertexLost: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when the picker is enabled or disabled
-     */
-    readonly onEnabled: Event<boolean>;
-    /**
-     * A reference to the Components instance associated with this VertexPicker.
-     */
-    components: Components;
-    /**
-     * A reference to the working plane used for vertex picking.
-     * This plane is used to determine which vertices are considered valid for picking.
-     * If this value is null, all vertices are considered valid.
-     */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
-    /**
-     * Sets the enabled state of the VertexPicker.
-     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
-     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
-     *
-     * @param value - The new enabled state.
+     * @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.
      */
-    set enabled(value: boolean);
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
     /**
-     * Gets the current enabled state of the VertexPicker.
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
      *
-     * @returns The current enabled state.
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
      */
-    get enabled(): boolean;
+    round(vector: THREE.Vector3): void;
     /**
-     * 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.
+     * Calculates the volume of a set of fragments.
      *
-     * @example
-     * '''typescript
-     * vertexPicker.config = {
-     *   snapDistance: 0.5,
-     *   showOnlyVertex: true,
-     * };
-     * '''
-     */
-    set config(value: Partial<VertexPickerConfig>);
-    /**
-     * Gets the current configuration for the VertexPicker component.
+     * @param frags - A map of fragment IDs to their corresponding item IDs.
+     * @returns The total volume of the fragments and the bounding sphere.
      *
-     * @returns A copy of the current VertexPickerConfig object.
+     * @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.
      *
-     * @example
-     * '''typescript
-     * const currentConfig = vertexPicker.config;
-     * console.log(currentConfig.snapDistance); // Output: 0.25
-     * '''
+     * @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.
      */
-    get config(): Partial<VertexPickerConfig>;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
     /**
-     * Performs the vertex picking operation based on the current state of the VertexPicker.
-     *
-     * @param world - The World instance to use for raycasting.
+     * Calculates the total volume of a set of meshes.
      *
-     * @returns The current picked point, or null if no point is picked.
+     * @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 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'.
+     * This method calculates the volume of each mesh in the provided array and returns the total volume
+     * and its bounding sphere.
+     *
      */
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
+    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
+    private getFaceData;
+    private getVolumeOfMesh;
+    private getSignedVolumeOfTriangle;
 }
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
@@ -1188,6 +1095,7 @@ export declare class Classifier extends Component implements Disposable {
     bySpatialStructure(model: FRAGS.FragmentsGroup, config?: {
         useProperties?: boolean;
         isolate?: Set<number>;
+        systemName?: string;
     }): Promise<void>;
     /**
      * Sets the color of the specified fragments.
@@ -1267,6 +1175,70 @@ export declare class Exploder extends Component implements Disposable {
      */
     set(active: boolean): void;
 }
+import * as THREE from "three";
+import { Components } from "../Components";
+import { SimpleCamera } from "..";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+/**
+ * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
+ */
+export declare class OrthoPerspectiveCamera extends SimpleCamera {
+    /**
+     * A ProjectionManager instance that manages the projection modes of the camera.
+     */
+    readonly projection: ProjectionManager;
+    /**
+     * A THREE.OrthographicCamera instance that represents the orthographic camera.
+     * This camera is used when the projection mode is set to orthographic.
+     */
+    readonly threeOrtho: THREE.OrthographicCamera;
+    /**
+     * A THREE.PerspectiveCamera instance that represents the perspective camera.
+     * This camera is used when the projection mode is set to perspective.
+     */
+    readonly threePersp: THREE.PerspectiveCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    protected _mode: NavigationMode | null;
+    private previousSize;
+    /**
+     * Getter for the current navigation mode.
+     * Throws an error if the mode is not found or the camera is not initialized.
+     *
+     * @returns {NavigationMode} The current navigation mode.
+     *
+     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
+     */
+    get mode(): NavigationMode;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets a new {@link NavigationMode} and disables the previous one.
+     *
+     * @param mode - The {@link NavigationMode} to set.
+     */
+    set(mode: NavModeID): void;
+    /**
+     * Make the camera view fit all the specified meshes.
+     *
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
+     */
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    /**
+     * Allows or prevents all user input.
+     *
+     * @param active - whether to enable or disable user inputs.
+     */
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoPerspCameraAspect;
+}
 import * as FRAGS from "@thatopen/fragments";
 import { Components, Component } from "../../core";
 /**
@@ -1305,160 +1277,45 @@ export declare class Hider extends Component {
     isolate(items: FRAGS.FragmentIdMap): void;
     private updateCulledVisibility;
 }
-import * as WEBIFC from "web-ifc";
+import { Fragment, FragmentsGroup } from "@thatopen/fragments";
+import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
+import { Component, Components, Event, Disposable, DataMap } from "../../core";
+import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
 /**
- * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
+ * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
  */
-export declare class IfcLoader extends Component implements Disposable {
+export declare class FragmentsManager extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    readonly onDisposed: Event<unknown>;
     /**
-     * An event triggered when the IFC file starts loading.
+     * Event triggered when fragments are loaded.
      */
-    readonly onIfcStartedLoading: Event<void>;
+    readonly onFragmentsLoaded: Event<FragmentsGroup>;
     /**
-     * An event triggered when the setup process is completed.
+     * Event triggered when fragments are disposed.
      */
-    readonly onSetup: Event<void>;
+    readonly onFragmentsDisposed: Event<{
+        groupID: string;
+        fragmentIDs: string[];
+    }>;
     /**
-     * The settings for the IfcLoader.
-     * It includes options for excluding categories, setting WASM paths, and more.
+     * DataMap containing all loaded fragments.
+     * The key is the fragment's unique identifier, and the value is the fragment itself.
      */
-    settings: IfcFragmentSettings;
+    readonly list: DataMap<string, Fragment>;
     /**
-     * The instance of the Web-IFC library used for handling IFC data.
+     * DataMap containing all loaded fragment groups.
+     * The key is the group's unique identifier, and the value is the group itself.
      */
-    webIfc: WEBIFC.IfcAPI;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _material;
-    private _spatialTree;
-    private _metaData;
-    private _fragmentInstances;
-    private _civil;
-    private _visitedFragments;
-    private _materialT;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets up the IfcLoader component with the provided configuration.
-     *
-     * @param config - Optional configuration settings for the IfcLoader.
-     * If not provided, the existing settings will be used.
-     *
-     * @returns A Promise that resolves when the setup process is completed.
-     *
-     * @remarks
-     * If the 'autoSetWasm' option is enabled in the configuration,
-     * the method will automatically set the WASM paths for the Web-IFC library.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = new IfcLoader(components);
-     * await ifcLoader.setup({ autoSetWasm: true });
-     * '''
-     */
-    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
-    /**
-     * Loads an IFC file and processes it for 3D visualization.
-     *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @param coordinate - Optional boolean indicating whether to coordinate the loaded IFC data. Default is true.
-     *
-     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * const group = await ifcLoader.load(ifcData);
-     * '''
-     */
-    load(data: Uint8Array, coordinate?: boolean, name?: string): Promise<FRAGS.FragmentsGroup>;
-    /**
-     * Reads an IFC file and initializes the Web-IFC library.
-     *
-     * @param data - The Uint8Array containing the IFC file data.
-     *
-     * @returns A Promise that resolves when the IFC file is opened and initialized.
-     *
-     * @remarks
-     * This method sets the WASM path and initializes the Web-IFC library based on the provided settings.
-     * It also opens the IFC model using the provided data and settings.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * await ifcLoader.readIfcFile(ifcData);
-     * '''
-     */
-    readIfcFile(data: Uint8Array): Promise<number>;
-    /**
-     * Cleans up the IfcLoader component by resetting the Web-IFC library,
-     * clearing the visited fragments and fragment instances maps, and creating a new instance of the Web-IFC library.
-     *
-     * @remarks
-     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * ifcLoader.cleanUp();
-     * '''
-     */
-    cleanUp(): void;
-    private getAllGeometries;
-    private getMesh;
-    private getGeometry;
-    private autoSetWasm;
-}
-import { Fragment, FragmentsGroup } from "@thatopen/fragments";
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components, Event, Disposable, DataMap } from "../../core";
-import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
-/**
- * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
- */
-export declare class FragmentsManager extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Event triggered when fragments are loaded.
-     */
-    readonly onFragmentsLoaded: Event<FragmentsGroup>;
-    /**
-     * Event triggered when fragments are disposed.
-     */
-    readonly onFragmentsDisposed: Event<{
-        groupID: string;
-        fragmentIDs: string[];
-    }>;
-    /**
-     * DataMap containing all loaded fragments.
-     * The key is the fragment's unique identifier, and the value is the fragment itself.
-     */
-    readonly list: DataMap<string, Fragment>;
-    /**
-     * DataMap containing all loaded fragment groups.
-     * The key is the group's unique identifier, and the value is the group itself.
-     */
-    readonly groups: DataMap<string, FragmentsGroup>;
-    baseCoordinationModel: string;
-    baseCoordinationMatrix: THREE.Matrix4;
+    readonly groups: DataMap<string, FragmentsGroup>;
+    baseCoordinationModel: string;
+    baseCoordinationMatrix: THREE.Matrix4;
     /** {@link Component.enabled} */
     enabled: boolean;
     private _loader;
@@ -1573,105 +1430,119 @@ export declare class FragmentsManager extends Component implements Disposable {
     clone(model: FRAGS.FragmentsGroup, items?: FRAGS.FragmentIdMap): FragmentsGroup;
 }
 import * as WEBIFC from "web-ifc";
-import { Components, Disposable, Event, Component, AsyncEvent } from "../../core";
-import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
 /**
- * A component that handles the tiling of IFC geometries for efficient streaming. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcGeometryTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcGeometryTiler).
+ * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
  */
-export declare class IfcGeometryTiler extends Component implements Disposable {
+export declare class IfcLoader extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
-    /**
-     * Event triggered when geometry is streamed.
-     * Contains the streamed geometry data and its buffer.
-     */
-    readonly onGeometryStreamed: AsyncEvent<{
-        buffer: Uint8Array;
-        data: StreamedGeometries;
-    }>;
+    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Event triggered when assets are streamed.
-     * Contains the streamed assets.
+     * An event triggered when the IFC file starts loading.
      */
-    readonly onAssetStreamed: AsyncEvent<StreamedAsset[]>;
+    readonly onIfcStartedLoading: Event<void>;
     /**
-     * Event triggered to indicate the progress of the streaming process.
-     * Contains the progress percentage.
+     * An event triggered when the setup process is completed.
      */
-    readonly onProgress: AsyncEvent<number>;
+    readonly onSetup: Event<void>;
     /**
-     * Event triggered when the IFC file is loaded.
-     * Contains the loaded IFC file data.
+     * The settings for the IfcLoader.
+     * It includes options for excluding categories, setting WASM paths, and more.
      */
-    readonly onIfcLoaded: AsyncEvent<Uint8Array>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    settings: IfcFragmentSettings;
     /**
-     * Settings for the IfcGeometryTiler.
+     * The instance of the Web-IFC library used for handling IFC data.
      */
-    settings: IfcStreamingSettings;
+    webIfc: WEBIFC.IfcAPI;
     /** {@link Component.enabled} */
     enabled: boolean;
-    /**
-     * The WebIFC API instance used for IFC file processing.
-     */
-    webIfc: WEBIFC.IfcAPI;
-    private _nextAvailableID;
-    private _splittedGeometries;
+    private _material;
     private _spatialTree;
     private _metaData;
-    private _visitedGeometries;
-    private _streamSerializer;
-    private _geometries;
-    private _geometryCount;
+    private _fragmentInstances;
     private _civil;
-    private _groupSerializer;
-    private _assets;
-    private _meshesWithHoles;
+    private _visitedFragments;
+    private _materialT;
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
-     * This method streams the IFC file from a given buffer.
+     * Sets up the IfcLoader component with the provided configuration.
      *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @returns A Promise that resolves when the streaming process is complete.
+     * @param config - Optional configuration settings for the IfcLoader.
+     * If not provided, the existing settings will be used.
+     *
+     * @returns A Promise that resolves when the setup process is completed.
      *
      * @remarks
-     * This method cleans up any resources after the streaming process is complete.
+     * If the 'autoSetWasm' option is enabled in the configuration,
+     * the method will automatically set the WASM paths for the Web-IFC library.
      *
      * @example
      * '''typescript
-     * const ifcData = await fetch('path/to/ifc/file.ifc');
-     * const rawBuffer = await response.arrayBuffer();
-     * const ifcBuffer = new Uint8Array(rawBuffer);
-     * await ifcGeometryTiler.streamFromBuffer(ifcBuffer);
+     * const ifcLoader = new IfcLoader(components);
+     * await ifcLoader.setup({ autoSetWasm: true });
      * '''
      */
-    streamFromBuffer(data: Uint8Array): Promise<void>;
+    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
     /**
-     * This method streams the IFC file from a given callback.
+     * Loads an IFC file and processes it for 3D visualization.
      *
-     * @param loadCallback - The callback function that will be used to load the IFC file.
-     * @returns A Promise that resolves when the streaming process is complete.
+     * @param data - The Uint8Array containing the IFC file data.
+     * @param coordinate - Optional boolean indicating whether to coordinate the loaded IFC data. Default is true.
+     *
+     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * const group = await ifcLoader.load(ifcData);
+     * '''
+     */
+    load(data: Uint8Array, coordinate?: boolean, name?: string): Promise<FRAGS.FragmentsGroup>;
+    /**
+     * Reads an IFC file and initializes the Web-IFC library.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     *
+     * @returns A Promise that resolves when the IFC file is opened and initialized.
      *
      * @remarks
-     * This method cleans up any resources after the streaming process is complete.
+     * This method sets the WASM path and initializes the Web-IFC library based on the provided settings.
+     * It also opens the IFC model using the provided data and settings.
      *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * await ifcLoader.readIfcFile(ifcData);
+     * '''
      */
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllGeometries;
-    private cleanUp;
+    readIfcFile(data: Uint8Array): Promise<number>;
+    /**
+     * Cleans up the IfcLoader component by resetting the Web-IFC library,
+     * clearing the visited fragments and fragment instances maps, and creating a new instance of the Web-IFC library.
+     *
+     * @remarks
+     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * ifcLoader.cleanUp();
+     * '''
+     */
+    cleanUp(): void;
+    private getAllGeometries;
     private getMesh;
     private getGeometry;
-    private streamAssets;
-    private streamGeometries;
-    private registerGeometryData;
+    private autoSetWasm;
 }
 import * as WEBIFC from "web-ifc";
 import { AsyncEvent, Component, Disposable, Event } from "../../core";
@@ -1738,8 +1609,194 @@ export declare class IfcPropertiesTiler extends Component implements Disposable
     private streamAllProperties;
     private cleanUp;
 }
-import { XMLParser } from "fast-xml-parser";
-import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core";
+import * as WEBIFC from "web-ifc";
+import { Components, Disposable, Event, Component, AsyncEvent } from "../../core";
+import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
+/**
+ * A component that handles the tiling of IFC geometries for efficient streaming. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcGeometryTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcGeometryTiler).
+ */
+export declare class IfcGeometryTiler 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: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
+    /**
+     * Event triggered when geometry is streamed.
+     * Contains the streamed geometry data and its buffer.
+     */
+    readonly onGeometryStreamed: AsyncEvent<{
+        buffer: Uint8Array;
+        data: StreamedGeometries;
+    }>;
+    /**
+     * Event triggered when assets are streamed.
+     * Contains the streamed assets.
+     */
+    readonly onAssetStreamed: AsyncEvent<StreamedAsset[]>;
+    /**
+     * Event triggered to indicate the progress of the streaming process.
+     * Contains the progress percentage.
+     */
+    readonly onProgress: AsyncEvent<number>;
+    /**
+     * Event triggered when the IFC file is loaded.
+     * Contains the loaded IFC file data.
+     */
+    readonly onIfcLoaded: AsyncEvent<Uint8Array>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Settings for the IfcGeometryTiler.
+     */
+    settings: IfcStreamingSettings;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * The WebIFC API instance used for IFC file processing.
+     */
+    webIfc: WEBIFC.IfcAPI;
+    private _nextAvailableID;
+    private _splittedGeometries;
+    private _spatialTree;
+    private _metaData;
+    private _visitedGeometries;
+    private _streamSerializer;
+    private _geometries;
+    private _geometryCount;
+    private _civil;
+    private _groupSerializer;
+    private _assets;
+    private _meshesWithHoles;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * This method streams the IFC file from a given buffer.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
+     *
+     * @remarks
+     * This method cleans up any resources after the streaming process is complete.
+     *
+     * @example
+     * '''typescript
+     * const ifcData = await fetch('path/to/ifc/file.ifc');
+     * const rawBuffer = await response.arrayBuffer();
+     * const ifcBuffer = new Uint8Array(rawBuffer);
+     * await ifcGeometryTiler.streamFromBuffer(ifcBuffer);
+     * '''
+     */
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    /**
+     * This method streams the IFC file from a given callback.
+     *
+     * @param loadCallback - The callback function that will be used to load the IFC file.
+     * @returns A Promise that resolves when the streaming process is complete.
+     *
+     * @remarks
+     * This method cleans up any resources after the streaming process is complete.
+     *
+     */
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllGeometries;
+    private cleanUp;
+    private getMesh;
+    private getGeometry;
+    private streamAssets;
+    private streamGeometries;
+    private registerGeometryData;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { XMLParser } from "fast-xml-parser";
+import { Component, DataMap } from "../../core/Types";
+import { IDSCheckResult, IDSInfo, IDSSpecification, IfcVersion } from "./src";
+import { Components } from "../../core";
+/**
+ * Component that manages Information Delivery Specification (IDS) data.
+ * It provides functionality for importing, exporting, and manipulating IDS data.
+ */
+export declare class IDSSpecifications extends Component {
+    static uuid: "9f0b9f78-9b2e-481a-b766-2fbfd01f342c";
+    enabled: boolean;
+    static xmlParser: XMLParser;
+    constructor(components: Components);
+    readonly list: DataMap<string, IDSSpecification>;
+    /**
+     * Retrieves a FragmentIdMap based on the given IDSCheckResult array.
+     * The map separates the IDs into two categories: pass and fail.
+     *
+     * @param model - The FragmentsGroup model from which to retrieve the fragment map.
+     * @param result - An array of IDSCheckResult objects, each representing a check result.
+     *
+     * @returns An object containing two properties:
+     * - 'pass': A FragmentIdMap that passed the checks.
+     * - 'fail': A FragmentIdMap that failed the checks.
+     */
+    getFragmentIdMap(model: FRAGS.FragmentsGroup, result: IDSCheckResult[]): {
+        pass: FRAGS.FragmentIdMap;
+        fail: FRAGS.FragmentIdMap;
+    };
+    /**
+     * Creates a new IDSSpecification instance and adds it to the list.
+     *
+     * @param name - The name of the IDSSpecification.
+     * @param ifcVersion - An array of IfcVersion values that the specification supports.
+     *
+     * @returns The newly created IDSSpecification instance.
+     */
+    create(name: string, ifcVersion: IfcVersion[], identifier?: string): IDSSpecification;
+    /**
+     * Parses and processes an XML string containing Information Delivery Specification (IDS) data.
+     * It creates IDSSpecification instances based on the parsed data and returns them in an array.
+     * Also, the instances are added to the list array.
+     *
+     * @param data - The XML string to parse.
+     *
+     * @returns An array of IDSSpecification instances created from the parsed data.
+     */
+    load(data: string): IDSSpecification[];
+    /**
+     * Exports the IDSSpecifications data into an XML string.
+     *
+     * @param info - The metadata information for the exported XML.
+     * @param specifications - An optional iterable of IDSSpecification instances to export.
+     * If not provided, all specifications in the list will be exported.
+     *
+     * @returns A string containing the exported IDSSpecifications data in XML format.
+     */
+    export(info: IDSInfo, specifications?: Iterable<IDSSpecification>): string;
+}
+import * as WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
+ */
+export declare class IfcJsonExporter extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
+     */
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+}
+import { XMLParser } from "fast-xml-parser";
+import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core";
 import { BCFTopic, Topic, BCFTopicsConfigManager, BCFTopicsConfig } from "./src";
 import { Viewpoint } from "../../core/Viewpoints";
 /**
@@ -1852,253 +1909,40 @@ export declare class BCFTopics extends Component implements Disposable, Configur
         topics: Topic[];
     }>;
 }
-import * as FRAGS from "@thatopen/fragments";
-import { XMLParser } from "fast-xml-parser";
-import { Component, DataMap } from "../../core/Types";
-import { IDSCheckResult, IDSInfo, IDSSpecification, IfcVersion } from "./src";
-import { Components } from "../../core";
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+import { RelationsMap, ModelsRelationMap, InverseAttribute, IfcRelation, RelationsProcessingConfig, EntitiesRelatedEvent } from "./src";
 /**
- * Component that manages Information Delivery Specification (IDS) data.
- * It provides functionality for importing, exporting, and manipulating IDS data.
+ * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
  */
-export declare class IDSSpecifications extends Component {
-    static uuid: "9f0b9f78-9b2e-481a-b766-2fbfd01f342c";
-    enabled: boolean;
-    static xmlParser: XMLParser;
-    constructor(components: Components);
-    readonly list: DataMap<string, IDSSpecification>;
+export declare class IfcRelationsIndexer extends Component implements Disposable {
     /**
-     * Retrieves a FragmentIdMap based on the given IDSCheckResult array.
-     * The map separates the IDs into two categories: pass and fail.
-     *
-     * @param model - The FragmentsGroup model from which to retrieve the fragment map.
-     * @param result - An array of IDSCheckResult objects, each representing a check result.
-     *
-     * @returns An object containing two properties:
-     * - 'pass': A FragmentIdMap that passed the checks.
-     * - 'fail': A FragmentIdMap that failed the checks.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    getFragmentIdMap(model: FRAGS.FragmentsGroup, result: IDSCheckResult[]): {
-        pass: FRAGS.FragmentIdMap;
-        fail: FRAGS.FragmentIdMap;
-    };
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Creates a new IDSSpecification instance and adds it to the list.
-     *
-     * @param name - The name of the IDSSpecification.
-     * @param ifcVersion - An array of IfcVersion values that the specification supports.
+     * Event triggered when relations for a model have been indexed.
+     * This event provides the model's UUID and the relations map generated for that model.
      *
-     * @returns The newly created IDSSpecification instance.
+     * @property {string} modelID - The UUID of the model for which relations have been indexed.
+     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
+     * The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
      */
-    create(name: string, ifcVersion: IfcVersion[], identifier?: string): IDSSpecification;
+    readonly onRelationsIndexed: Event<{
+        modelID: string;
+        relationsMap: RelationsMap;
+    }>;
     /**
-     * Parses and processes an XML string containing Information Delivery Specification (IDS) data.
-     * It creates IDSSpecification instances based on the parsed data and returns them in an array.
-     * Also, the instances are added to the list array.
-     *
-     * @param data - The XML string to parse.
-     *
-     * @returns An array of IDSSpecification instances created from the parsed data.
-     */
-    load(data: string): IDSSpecification[];
-    /**
-     * Exports the IDSSpecifications data into an XML string.
-     *
-     * @param info - The metadata information for the exported XML.
-     * @param specifications - An optional iterable of IDSSpecification instances to export.
-     * If not provided, all specifications in the list will be exported.
-     *
-     * @returns A string containing the exported IDSSpecifications data in XML format.
-     */
-    export(info: IDSInfo, specifications?: Iterable<IDSSpecification>): string;
-}
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Represents an edge measurement result.
- */
-export interface MeasureEdge {
-    /**
-     * The distance between the two points of the edge.
-     */
-    distance: number;
-    /**
-     * The two points that define the edge.
-     */
-    points: THREE.Vector3[];
-}
-/**
- * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
- */
-export declare class MeasurementUtils extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Utility method to calculate the distance from a point to a line segment.
-     *
-     * @param point - The point from which to calculate the distance.
-     * @param lineStart - The start point of the line segment.
-     * @param lineEnd - The end point of the line segment.
-     * @param clamp - If true, the distance will be clamped to the line segment's length.
-     * @returns The distance from the point to the line segment.
-     */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    /**
-     * Method to get the face of a mesh that contains a given triangle index.
-     * It also returns the edges of the found face and their indices.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param triangleIndex - The index of the triangle within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
-     */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
-     */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
-     *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
-     */
-    round(vector: THREE.Vector3): void;
-    /**
-     * Calculates the volume of a set of fragments.
-     *
-     * @param frags - A map of fragment IDs to their corresponding item IDs.
-     * @returns The total volume of the fragments and the bounding sphere.
-     *
-     * @remarks
-     * This method creates a set of instanced meshes from the given fragments and item IDs.
-     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
-     *
-     * @throws Will throw an error if the geometry of the meshes is not indexed.
-     * @throws Will throw an error if the fragment manager is not available.
-     */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
-    /**
-     * Calculates the total volume of a set of meshes.
-     *
-     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
-     * @returns The total volume of the meshes and the bounding sphere.
-     *
-     * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
-     *
-     */
-    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
-    private getFaceData;
-    private getVolumeOfMesh;
-    private getSignedVolumeOfTriangle;
-}
-import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
- */
-export declare class IfcJsonExporter extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
-     */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
-}
-import { 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, 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).
- */
-export declare class IfcRelationsIndexer extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Event triggered when relations for a model have been indexed.
-     * This event provides the model's UUID and the relations map generated for that model.
-     *
-     * @property {string} modelID - The UUID of the model for which relations have been indexed.
-     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
-     * The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
-     */
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
-    /**
-     * Holds the relationship mappings for each model processed by the indexer.
-     * The structure is a map where each key is a model's UUID, and the value is another map.
-     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
-     * representing a specific relation type, and the value is an array of expressIDs of entities
-     * that are related through that relation type. This structure allows for efficient querying
-     * of entity relationships within a model.
+     * Holds the relationship mappings for each model processed by the indexer.
+     * The structure is a map where each key is a model's UUID, and the value is another map.
+     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
+     * representing a specific relation type, and the value is an array of expressIDs of entities
+     * that are related through that relation type. This structure allows for efficient querying
+     * of entity relationships within a model.
      */
     readonly relationMaps: ModelsRelationMap;
     /** {@link Component.enabled} */
@@ -2591,53 +2435,210 @@ 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";
-import { Clipper } from "../index";
-type ClipperConfigType = {
-    enabled: BooleanSettingsControl;
-    visible: BooleanSettingsControl;
-    color: ColorSettingsControl;
-    opacity: NumberSettingControl;
-    size: NumberSettingControl;
+export declare function obbFromPoints(vertices: ArrayLike<number>): {
+    center: THREE.Vector3;
+    halfSizes: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    transformation: THREE.Matrix4;
 };
-/**
- * Configuration interface for the {@link Clipper}.
- */
-export interface ClipperConfig {
-    color: THREE.Color;
-    opacity: number;
-    size: number;
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
 }
-export declare class ClipperConfigManager extends Configurator<Clipper, ClipperConfigType> {
-    protected _config: ClipperConfigType;
-    get enabled(): boolean;
-    set enabled(value: boolean);
-    get visible(): boolean;
-    set visible(value: boolean);
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get opacity(): number;
-    set opacity(value: number);
-    get size(): number;
-    set size(value: number);
+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;
 }
-export {};
+import * as THREE from "three";
+import { Component, Components, Disposable, Event, World } from "../core";
 /**
- * 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.
- *
+ * Configuration interface for the VertexPicker component.
+ */
+export interface VertexPickerConfig {
+    /**
+     * If true, only vertices will be picked, not the closest point on the face.
+     */
+    showOnlyVertex: boolean;
+    /**
+     * The maximum distance for snapping to a vertex.
+     */
+    snapDistance: number;
+    /**
+     * The HTML element to use for previewing the picked vertex.
+     */
+    previewElement: HTMLElement;
+}
+/**
+ * A class that provides functionality for picking vertices in a 3D scene.
+ */
+export declare class VertexPicker extends Component implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
+     */
+    readonly onVertexFound: Event<THREE.Vector3>;
+    /**
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
+     */
+    readonly onVertexLost: Event<THREE.Vector3>;
+    /**
+     * An event that is triggered when the picker is enabled or disabled
+     */
+    readonly onEnabled: Event<boolean>;
+    /**
+     * A reference to the Components instance associated with this VertexPicker.
+     */
+    components: Components;
+    /**
+     * A reference to the working plane used for vertex picking.
+     * This plane is used to determine which vertices are considered valid for picking.
+     * If this value is null, all vertices are considered valid.
+     */
+    workingPlane: THREE.Plane | null;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
+    /**
+     * Sets the enabled state of the VertexPicker.
+     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
+     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
+     *
+     * @param value - The new enabled state.
+     */
+    set enabled(value: boolean);
+    /**
+     * Gets the current enabled state of the VertexPicker.
+     *
+     * @returns The current enabled state.
+     */
+    get enabled(): boolean;
+    /**
+     * Sets the configuration for the VertexPicker component.
+     *
+     * @param value - A Partial object containing the configuration properties to update.
+     * The properties not provided in the value object will retain their current values.
+     *
+     * @example
+     * '''typescript
+     * vertexPicker.config = {
+     *   snapDistance: 0.5,
+     *   showOnlyVertex: true,
+     * };
+     * '''
+     */
+    set config(value: Partial<VertexPickerConfig>);
+    /**
+     * Gets the current configuration for the VertexPicker component.
+     *
+     * @returns A copy of the current VertexPickerConfig object.
+     *
+     * @example
+     * '''typescript
+     * const currentConfig = vertexPicker.config;
+     * console.log(currentConfig.snapDistance); // Output: 0.25
+     * '''
+     */
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
+     *
+     * @param world - The World instance to use for raycasting.
+     *
+     * @returns The current picked point, or null if no point is picked.
+     *
+     * @remarks
+     * This method checks if the VertexPicker is enabled. If not, it returns the current picked point.
+     * If enabled, it performs raycasting to find the closest intersecting object.
+     * It then determines the closest vertex or point on the face, based on the configuration settings.
+     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
+     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
+     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
+     */
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+import { BooleanSettingsControl } from "../../Types";
+import { Viewpoints } from "../index";
+import { Configurator } from "../../ConfigManager";
+/**
+ * Configuration interface for the Viewpoints general behavior.
+ */
+export interface ViewpointsConfig {
+    /**
+     * 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 THREE from "three";
+import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+import { Clipper } from "../index";
+type ClipperConfigType = {
+    enabled: BooleanSettingsControl;
+    visible: BooleanSettingsControl;
+    color: ColorSettingsControl;
+    opacity: NumberSettingControl;
+    size: NumberSettingControl;
+};
+/**
+ * Configuration interface for the {@link Clipper}.
+ */
+export interface ClipperConfig {
+    color: THREE.Color;
+    opacity: number;
+    size: number;
+}
+export declare class ClipperConfigManager extends Configurator<Clipper, ClipperConfigType> {
+    protected _config: ClipperConfigType;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get visible(): boolean;
+    set visible(value: boolean);
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get opacity(): number;
+    set opacity(value: number);
+    get size(): number;
+    set size(value: number);
+}
+export {};
+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;
@@ -2676,26 +2677,6 @@ export declare class IfcPropertiesUtils {
 export declare const ifcCategoryCase: {
     [upperCase: string]: string;
 };
-/**
- * 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";
@@ -2766,6 +2747,14 @@ export declare class IfcQueryGroup {
     update(modelID: string, file: File): Promise<void>;
 }
 import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
+}
+import * as WEBIFC from "web-ifc";
 /** Configuration of the IFC-fragment conversion. */
 export declare class IfcFragmentSettings {
     /** Whether to extract the IFC properties into a JSON. */
@@ -2806,383 +2795,578 @@ export declare class IfcFragmentSettings {
      */
     customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
 }
+import * as FRAGS from "@thatopen/fragments";
+import * as WEBIFC from "web-ifc";
+export declare class SpatialIdsFinder {
+    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+}
+/**
+ * A Set of unique numbers representing different types of IFC geometries.
+ */
+export declare const GeometryTypes: Set<number>;
 import { InverseAttribute } from "./types";
 export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856 | 2857406711 | 2565941209 | 2495723537 | 3268803585 | 982818633, {
     forRelating: InverseAttribute;
     forRelated: InverseAttribute;
 }>;
-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;
-}
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createPropertyFacets: (components: Components, elements: any) => IDSFacet[];
 /**
- * Represents a viewpoint in a BCF file.
+ * 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 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;
+export declare class Event<T> {
+    /**
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
+     */
+    add(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /**
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
+     */
+    remove(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => void;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
+}
+/**
+ * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
+ */
+export declare class AsyncEvent<T> {
+    /**
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
+     */
+    add(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /**
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
+     */
+    remove(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => Promise<void>;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
 }
 import * as THREE from "three";
-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";
+import CameraControls from "camera-controls";
+import { Event } from "./event";
 /**
- * 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.
+ * Whether this component has to be manually destroyed once you are done with it to prevent [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects). This also ensures that the DOM events created by that component will be cleaned up.
  */
-export declare class Viewpoint implements BCFViewpoint {
-    title?: string;
-    readonly guid: string;
+export interface Disposable {
     /**
-     * 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
+     * Destroys the object from memory to prevent a
+     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
      */
-    clippingPlanes: DataSet<SimplePlane>;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
+    dispose: () => void | Promise<void>;
+    /** Fired after the tool has been disposed.  */
+    readonly onDisposed: Event<any>;
+}
+/**
+ * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
+ */
+export interface Hideable {
     /**
-     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
+     * Whether the geometric representation of this component is
+     * currently visible or not in the
+     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
      */
-    readonly exceptionComponents: DataSet<string>;
+    visible: boolean;
+}
+/**
+ * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
+ */
+export interface Resizeable {
     /**
-     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
+     * Sets size of this component (e.g. the resolution of a
+     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+     * component.
      */
-    readonly selectionComponents: DataSet<string>;
+    resize: (size?: THREE.Vector2) => void;
+    /** Event that fires when the component has been resized. */
+    onResize: Event<THREE.Vector2>;
     /**
-     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
-     * For this to work, call viewpoint.colorize()
+     * Gets the current size of this component (e.g. the resolution of a
+     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+     * component.
      */
-    readonly componentColors: DataMap<THREE.Color, string[]>;
+    getSize: () => THREE.Vector2;
+}
+/** Whether this component should be updated each frame. */
+export interface Updateable {
+    /** Actions that should be executed after updating the component. */
+    onAfterUpdate: Event<any>;
+    /** Actions that should be executed before updating the component. */
+    onBeforeUpdate: Event<any>;
     /**
-     * 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
+     * Function used to update the state of this component each frame. For
+     * instance, a renderer component will make a render each frame.
      */
-    spacesVisible: boolean;
+    update(delta?: number): void;
+}
+/** Basic type to describe the progress of any kind of process. */
+export interface Progress {
+    /** The amount of things that have been done already. */
+    current: number;
+    /** The total amount of things to be done by the process. */
+    total: number;
+}
+/**
+ * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
+ */
+export interface Createable {
+    /** Creates a new instance of an element (e.g. a new Dimension). */
+    create: (data: any) => void;
     /**
-     * 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
+     * Finish the creation process of the component, successfully creating an
+     * instance of whatever the component creates.
      */
-    spaceBoundariesVisible: boolean;
+    endCreation?: (data: any) => void;
     /**
-     * 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
+     * Cancels the creation process of the component, going back to the state
+     * before starting to create.
      */
-    openingsVisible: boolean;
+    cancelCreation?: (data: any) => void;
+    /** Deletes an existing instance of an element (e.g. a Dimension). */
+    delete: (data: any) => void;
+}
+/**
+ * Whether this component supports to be configured.
+ */
+export interface Configurable<T, U> {
+    /** Wether this components has been already configured. */
+    isSetup: boolean;
+    /** Use the provided configuration to set up the tool. */
+    setup: (config?: Partial<U>) => void | Promise<void>;
+    /** Fired after successfully calling {@link Configurable.setup()}  */
+    readonly onSetup: Event<any>;
+    /** Object holding the tool configuration. You can edit this directly to change the object.
+     */
+    config: Required<T>;
+}
+/**
+ * Whether a camera uses the Camera Controls library.
+ */
+export interface CameraControllable {
     /**
-     * When true, all components should be visible unless listed in the exceptions
-     * When false all components should be invisible unless listed in the exceptions
+     * An instance of CameraControls that provides camera control functionalities.
+     * This instance is used to manipulate the camera.
      */
-    defaultVisibility: boolean;
-    private get _selectionModelIdMap();
-    private get _exceptionModelIdMap();
+    controls: CameraControls;
+}
+import { Base } from "./base";
+/**
+ * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
+ */
+export declare abstract class Component extends Base {
     /**
-     * A list of components that should be selected (highlighted) when displaying a viewpoint.
-     * @returns The fragmentIdMap for components marked as selections.
+     * Whether this component is active or not. The behaviour can vary depending
+     * on the type of component. E.g. a disabled dimension tool will stop creating
+     * dimensions, while a disabled camera will stop moving. A disabled component
+     * will not be updated automatically each frame.
      */
-    get selection(): FRAGS.FragmentIdMap;
+    abstract enabled: boolean;
+}
+import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
+import { Components } from "../../Components";
+/**
+ * Base class of the library. Useful for finding out the interfaces something implements.
+ */
+export declare abstract class Base {
+    components: Components;
+    constructor(components: Components);
+    /** Whether is component is {@link Disposable}. */
+    isDisposeable: () => this is Disposable;
+    /** Whether is component is {@link Resizeable}. */
+    isResizeable: () => this is Resizeable;
+    /** Whether is component is {@link Updateable}. */
+    isUpdateable: () => this is Updateable;
+    /** Whether is component is {@link Hideable}. */
+    isHideable: () => this is Hideable;
+    /** Whether is component is {@link Configurable}. */
+    isConfigurable: () => this is Configurable<any, any>;
+}
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { BaseWorldItem } from "./base-world-item";
+import { CameraControllable } from "./interfaces";
+/**
+ * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
+ */
+export declare abstract class BaseCamera extends BaseWorldItem {
     /**
-     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
-     * @returns The fragmentIdMap for components marked as exceptions.
+     * Whether the camera is enabled or not.
      */
-    get exception(): FRAGS.FragmentIdMap;
+    abstract enabled: boolean;
     /**
-     * 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'.
+     * The Three.js camera instance.
      */
-    get projection(): CameraProjection;
+    abstract three: THREE.Camera;
     /**
-     * Retrieves the position vector of the viewpoint's 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}.
      *
-     * @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 True if the instance is controllable, false otherwise.
+     */
+    hasCameraControls: () => this is CameraControllable;
+}
+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 { Vector2 } from "three";
+import { Event } from "./event";
+import { BaseWorldItem } from "./base-world-item";
+import { Disposable, Resizeable, Updateable } from "./interfaces";
+/**
+ * Abstract class representing a renderer for a 3D world. All renderers should use this class as a base.
+ */
+export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
+    /**
+     * The three.js WebGLRenderer instance associated with this renderer.
      *
-     * @returns A THREE.Vector3 representing the position of the viewpoint's camera.
+     * @abstract
+     * @type {THREE.WebGLRenderer}
      */
-    get position(): THREE.Vector3;
+    abstract three: THREE.WebGLRenderer;
+    /** {@link Updateable.onBeforeUpdate} */
+    onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onAfterUpdate} */
+    onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<undefined>;
+    /** {@link Resizeable.onResize} */
+    readonly onResize: Event<THREE.Vector2>;
     /**
-     * Retrieves the direction vector of the viewpoint's camera.
+     * Event that fires when there has been a change to the list of clipping
+     * planes used by the active renderer.
+     */
+    readonly onClippingPlanesUpdated: Event<unknown>;
+    /** {@link Updateable.update} */
+    abstract update(delta?: number): void | Promise<void>;
+    /** {@link Disposable.dispose} */
+    abstract dispose(): void;
+    /** {@link Resizeable.getSize} */
+    abstract getSize(): Vector2;
+    /** {@link Resizeable.resize} */
+    abstract resize(size: Vector2 | undefined): void;
+    /**
+     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
+     */
+    clippingPlanes: THREE.Plane[];
+    /**
+     * Updates the clipping planes and triggers the 'onClippingPlanesUpdated' event.
      *
      * @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.
+     * This method is typically called when there is a change to the list of clipping planes
+     * used by the active renderer.
+     */
+    updateClippingPlanes(): void;
+    /**
+     * Sets or removes a clipping plane from the renderer.
      *
-     * @returns A THREE.Vector3 representing the direction of the viewpoint's camera.
+     * @param active - A boolean indicating whether the clipping plane should be active or not.
+     * @param plane - The clipping plane to be added or removed.
+     * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to 'false'.
+     *
+     * @remarks
+     * This method adds or removes a clipping plane from the 'clippingPlanes' array.
+     * If 'active' is 'true' and the plane is not already in the array, it is added.
+     * If 'active' is 'false' and the plane is in the array, it is removed.
+     * The 'three.clippingPlanes' property is then updated to reflect the current state of the 'clippingPlanes' array,
+     * excluding any planes marked as local.
      */
-    get direction(): THREE.Vector3;
-    private _components;
+    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
+}
+import * as THREE from "three";
+import { Disposable } from "./interfaces";
+import { Event } from "./event";
+import { Components } from "../../Components";
+import { BaseWorldItem } from "./base-world-item";
+/**
+ * Abstract class representing a base scene in the application. All scenes should use this class as a base.
+ */
+export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Abstract property representing the three.js object associated with this scene.
+     * It should be implemented by subclasses.
+     */
+    abstract three: THREE.Object3D;
+    /** The set of directional lights managed by this scene component. */
+    directionalLights: Map<string, THREE.DirectionalLight>;
+    /** The set of ambient lights managed by this scene component. */
+    ambientLights: Map<string, THREE.AmbientLight>;
+    protected constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    deleteAllLights(): void;
+}
+import { Event } from "./event";
+/**
+ * A class that extends the built-in Set class and provides additional functionality.
+ * It triggers events when items are added, deleted, or the set is cleared.
+ *
+ * @template T - The type of elements in the set.
+ */
+export declare class DataSet<T> extends Set<T> {
     /**
-     * Represents the world in which the viewpoints are created and managed.
+     * An event that is triggered when a new item is added to the set.
      */
-    readonly world: World;
-    private get _managerVersion();
+    readonly onItemAdded: Event<T>;
     /**
-     * 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.
+     * An event that is triggered when an item is deleted from the set.
      */
-    get topics(): import("../../../openbim/BCFTopics").Topic[];
-    constructor(components: Components, world: World, _config?: {
-        data?: Partial<BCFViewpoint>;
-        setCamera?: boolean;
-    });
+    readonly onItemDeleted: Event<unknown>;
     /**
-     * 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.
+     * An event that is triggered when the set is cleared.
      */
-    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
+    readonly onCleared: Event<unknown>;
     /**
-     * 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.
+     * Constructs a new instance of the DataSet class.
      *
-     * @returns The viewpoint instance with the updated properties.
+     * @param iterable - An optional iterable object to initialize the set with.
      */
-    set(data: Partial<BCFViewpoint>): this;
+    constructor(iterable?: Iterable<T> | null);
     /**
-     * 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.
+     * Clears the set and triggers the onCleared event.
      */
-    go(transition?: boolean): Promise<void>;
+    clear(): 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.
+     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
      *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
+     * @param value - The value to add to the set.
+     * @returns - The set instance.
      */
-    updateCamera(): void;
-    applyVisibility(): void;
+    add(...value: T[]): this;
     /**
-     * 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.
+     * A function that acts as a guard for adding items to the set.
+     * It determines whether a given value should be allowed to be added to the set.
      *
-     * @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.
+     * @param value - The value to be checked against the guard.
+     * @returns A boolean indicating whether the value should be allowed to be added to the set.
+     *          By default, this function always returns true, allowing all values to be added.
+     *          You can override this behavior by providing a custom implementation.
      */
-    resetColors(): void;
-    private createComponentTags;
-    private createColorTags;
+    guard: (value: T) => boolean;
     /**
-     * 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.
+     * Deletes a value from the set and triggers the onItemDeleted event.
      *
-     * @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.
+     * @param value - The value to delete from the set.
+     * @returns - True if the value was successfully deleted, false otherwise.
      */
-    get fade(): boolean;
+    delete(value: T): boolean;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
      */
-    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;
-};
+import { BaseScene } from "./base-scene";
+import { BaseCamera } from "./base-camera";
+import { BaseRenderer } from "./base-renderer";
+import { Updateable, Disposable } from "./interfaces";
 /**
- * Configuration interface for the {@link SimpleGrid}.
+ * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
  */
-export interface SimpleGridConfig {
+export interface World extends Disposable, Updateable {
     /**
-     * Whether the grid is visible or not.
+     * A set of meshes present in the world. This is taken into account for operations like raycasting.
      */
-    visible: boolean;
+    meshes: Set<THREE.Mesh>;
     /**
-     * The color of the grid lines.
+     * The base scene of the world.
      */
-    color: THREE.Color;
+    scene: BaseScene;
     /**
-     * The size of the primary grid lines.
+     * The base camera of the world.
      */
-    primarySize: number;
+    camera: BaseCamera;
     /**
-     * The size of the secondary grid lines.
+     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
      */
-    secondarySize: number;
+    renderer: BaseRenderer | null;
     /**
-     * The distance at which the grid lines start to fade away.
+     * A unique identifier for the world.
      */
-    distance: number;
+    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;
 }
-export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
-    protected _config: SimpleGridConfigType;
+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.
+ *
+ * @template K - The type of keys in the map.
+ * @template V - The type of values in the map.
+ */
+export declare class DataMap<K, V> extends Map<K, V> {
     /**
-     * Whether the grid is visible or not.
+     * An event triggered when a new item is set in the map.
      */
-    get visible(): boolean;
+    readonly onItemSet: Event<{
+        key: K;
+        value: V;
+    }>;
     /**
-     * Whether the grid is visible or not.
+     * An event triggered when an existing item in the map is updated.
      */
-    set visible(value: boolean);
+    readonly onItemUpdated: Event<{
+        key: K;
+        value: V;
+    }>;
     /**
-     * The color of the grid lines.
+     * An event triggered when an item is deleted from the map.
      */
-    get color(): THREE.Color;
+    readonly onItemDeleted: Event<K>;
     /**
-     * The color of the grid lines.
+     * An event triggered when the map is cleared.
      */
-    set color(value: THREE.Color);
+    readonly onCleared: Event<unknown>;
     /**
-     * The size of the primary grid lines.
+     * Constructs a new DataMap instance.
+     *
+     * @param iterable - An iterable object containing key-value pairs to populate the map.
      */
-    get primarySize(): number;
+    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
     /**
-     * The size of the primary grid lines.
+     * Clears the map and triggers the onCleared event.
      */
-    set primarySize(value: number);
+    clear(): void;
     /**
-     * The size of the secondary grid lines.
+     * Sets the value for the specified key in the map and triggers the appropriate event (onItemSet or onItemUpdated).
+     *
+     * @param key - The key of the item to set.
+     * @param value - The value of the item to set.
+     * @returns The DataMap instance.
      */
-    get secondarySize(): number;
+    set(key: K, value: V): this;
     /**
-     * The size of the secondary grid lines.
+     * A function that acts as a guard for adding items to the set.
+     * It determines whether a given value should be allowed to be added to the set.
+     *
+     * @param key - The key of the entry to be checked against the guard.
+     * @param value - The value of the entry to be checked against the guard.
+     * @returns A boolean indicating whether the value should be allowed to be added to the set.
+     *          By default, this function always returns true, allowing all values to be added.
+     *          You can override this behavior by providing a custom implementation.
      */
-    set secondarySize(value: number);
+    guard: (key: K, value: V) => boolean;
     /**
-     * The distance at which the grid lines start to fade away.
+     * Deletes the specified key from the map and triggers the onItemDeleted event if the key was found.
+     *
+     * @param key - The key of the item to delete.
+     * @returns True if the key was found and deleted; otherwise, false.
      */
-    get distance(): number;
+    delete(key: K): boolean;
     /**
-     * The distance at which the grid lines start to fade away.
+     * Clears the map and resets the events.
      */
-    set distance(value: number);
+    dispose(): void;
+}
+import { Component } from "./component";
+export type ComponentUIElement = {
+    name: string;
+    componentID: string;
+    attributes: {
+        [name: string]: string;
+    };
+    get: () => HTMLElement;
+};
+export declare abstract class ComponentWithUI extends Component {
+    abstract name: string;
+    abstract getUI(): ComponentUIElement[];
+}
+import * as THREE from "three";
+export interface BooleanSettingsControl {
+    type: "Boolean";
+    value: boolean;
+}
+export interface ColorSettingsControl {
+    type: "Color";
+    value: THREE.Color;
+}
+export interface TextSettingsControl {
+    type: "Text";
+    value: string;
+}
+export interface NumberSettingControl {
+    type: "Number";
+    interpolable: boolean;
+    min?: number;
+    max?: number;
+    value: number;
+}
+export interface SelectSettingControl {
+    type: "Select";
+    multiple: boolean;
+    options: Set<string>;
+    value: string;
+}
+export interface Vector3SettingControl {
+    type: "Vector3";
+    value: THREE.Vector3;
+}
+export interface TextSetSettingControl {
+    type: "TextSet";
+    value: Set<string>;
+}
+export interface NoControl {
+    type: "None";
+    value: any;
+}
+export type ControlEntry = BooleanSettingsControl | ColorSettingsControl | TextSettingsControl | NumberSettingControl | SelectSettingControl | Vector3SettingControl | TextSetSettingControl | NoControl;
+export interface ControlsSchema {
+    [name: string]: ControlEntry | ControlsSchema;
 }
-export {};
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable, Configurable } from "../../Types";
 import { MiniMapConfig, MiniMapConfigManager } from "./mini-map-config";
@@ -3396,29 +3580,216 @@ export declare class MiniMapConfigManager extends Configurator<MiniMap, MiniMapC
 }
 export {};
 import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
 import { Components } from "../../Components";
-import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
+import { AsyncEvent, Configurable, Event, World } from "../../Types";
+import { CullerRendererConfig, CullerRendererConfigManager } from "./culler-renderer-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.
+ * A base renderer to determine visibility on screen.
  */
-export declare class SimpleScene extends BaseScene implements Configurable<SimpleSceneConfigManager, SimpleSceneConfig> {
+export declare class CullerRenderer implements Configurable<CullerRendererConfigManager, CullerRendererConfig> {
     /** {@link Configurable.onSetup} */
     readonly onSetup: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * Fires after making the visibility check to the meshes. It lists the
+     * meshes that are currently visible, and the ones that were visible
+     * just before but not anymore.
+     */
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
+    /**
+     * Whether this renderer is active or not. If not, it won't render anything.
+     */
+    enabled: boolean;
+    /**
+     * Needs to check whether there are objects that need to be hidden or shown.
+     * You can bind this to the camera movement, to a certain interval, etc.
+     */
+    needsUpdate: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /** The render target used to render the visibility scene. */
+    renderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
+    /**
+     * The size of the buffer where the result of the visibility check is stored.
+     */
+    bufferSize: number;
+    /**
+     * The buffer when the result of the visibility check is stored.
+     */
+    buffer: Uint8Array;
+    /**
+     * Flag to indicate if the renderer shouldn't update the visibility.
+     */
+    preventUpdate: boolean;
+    /** {@link Configurable.config} */
+    config: CullerRendererConfigManager;
     /** {@link Configurable.isSetup} */
     isSetup: boolean;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected _defaultConfig: CullerRendererConfig;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _availableColor;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    updateVisibility: (force?: boolean) => Promise<void>;
+    setup(config?: Partial<CullerRendererConfig>): void;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
+}
+export declare 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 { 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;
+}
+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;
     /**
-     * The underlying Three.js scene object.
-     * It is used to define the 3D space containing objects, lights, and cameras.
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
      */
-    three: THREE.Scene;
-    /** {@link Configurable.config} */
-    config: SimpleSceneConfigManager;
-    protected _defaultConfig: SimpleSceneConfig;
-    constructor(components: Components);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): void;
+    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, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
@@ -3500,58 +3871,29 @@ export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends Base
     dispose(disposeResources?: boolean): void;
 }
 import * as THREE from "three";
-import { BaseRenderer, Event } from "../../Types";
+import { BaseScene, Configurable, Event } from "../../Types";
 import { Components } from "../../Components";
+import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
 /**
- * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
+ * 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 SimpleRenderer extends BaseRenderer {
-    /**
-     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
-     * Default is 'true'.
-     */
-    enabled: boolean;
-    /**
-     * The HTML container of the THREE.js canvas where the scene is rendered.
-     */
-    container: HTMLElement;
-    /**
-     * The THREE.js WebGLRenderer instance.
-     */
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
+export declare class SimpleScene extends BaseScene implements Configurable<SimpleSceneConfigManager, SimpleSceneConfig> {
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
     /**
-     * Constructor for the SimpleRenderer class.
-     *
-     * @param components - The components instance.
-     * @param container - The HTML container where the THREE.js canvas will be rendered.
-     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
      */
-    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@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;
-    /** {@link Resizeable.getSize}. */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize: (size?: THREE.Vector2) => void;
-    /**
-     * Sets up and manages the event listeners for the renderer.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
-     *
-     * @throws Will throw an error if the renderer does not have an HTML container.
-     */
-    setupEvents(active: boolean): void;
-    private resizeEvent;
-    private setupRenderer;
-    private onContextLost;
-    private onContextBack;
 }
 import * as THREE from "three";
 import CameraControls from "camera-controls";
@@ -3609,163 +3951,22 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
      * Updates the aspect of the camera to match the size of the
      * {@link Components.renderer}.
      */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
-}
-import * as THREE from "three";
-import { 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 { 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;
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
+}
+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 { SimpleScene } from "./simple-scene";
@@ -3827,619 +4028,419 @@ export declare class SimpleSceneConfigManager extends Configurator<SimpleScene,
 }
 export {};
 import * as THREE from "three";
-import { CullerRenderer } from "./culler-renderer";
+import { BaseRenderer, Event } from "../../Types";
 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.
+ * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
  */
-export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
+export declare class SimpleRenderer extends BaseRenderer {
     /**
-     * Event triggered when the visibility of meshes is updated.
-     * Contains two sets: seen and unseen.
+     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
+     * Default is 'true'.
      */
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
-    }>;
+    enabled: boolean;
     /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
+     * The HTML container of the THREE.js canvas where the scene is rendered.
      */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    container: HTMLElement;
     /**
-     * @deprecated use config.threshold instead.
+     * The THREE.js WebGLRenderer instance.
      */
-    get threshold(): number;
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<unknown>;
+    private _resizing;
     /**
-     * @deprecated use config.threshold instead.
+     * Constructor for the SimpleRenderer class.
+     *
+     * @param components - The components instance.
+     * @param container - The HTML container where the THREE.js canvas will be rendered.
+     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
      */
-    set threshold(value: number);
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World);
+    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
+    /** {@link Updateable.update} */
+    update(): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /** {@link Resizeable.getSize}. */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize: (size?: THREE.Vector2) => void;
     /**
-     * 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.
+     * Sets up and manages the event listeners for the renderer.
      *
-     * @param meshes - The meshes to update.
+     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
      *
-     * @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.
-     */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
-     */
-    remove(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => void;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}
-/**
- * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
- */
-export declare class AsyncEvent<T> {
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
-     */
-    add(handler: T extends void ? {
-        (): Promise<void>;
-    } : {
-        (data: T): Promise<void>;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
-     */
-    remove(handler: T extends void ? {
-        (): Promise<void>;
-    } : {
-        (data: T): Promise<void>;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => Promise<void>;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Event } from "./event";
-/**
- * Whether this component has to be manually destroyed once you are done with it to prevent [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects). This also ensures that the DOM events created by that component will be cleaned up.
- */
-export interface Disposable {
-    /**
-     * Destroys the object from memory to prevent a
-     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
-     */
-    dispose: () => void | Promise<void>;
-    /** Fired after the tool has been disposed.  */
-    readonly onDisposed: Event<any>;
-}
-/**
- * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
- */
-export interface Hideable {
-    /**
-     * Whether the geometric representation of this component is
-     * currently visible or not in the
-     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
-     */
-    visible: boolean;
-}
-/**
- * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
- */
-export interface Resizeable {
-    /**
-     * Sets size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
-     */
-    resize: (size?: THREE.Vector2) => void;
-    /** Event that fires when the component has been resized. */
-    onResize: Event<THREE.Vector2>;
-    /**
-     * Gets the current size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
-     */
-    getSize: () => THREE.Vector2;
-}
-/** Whether this component should be updated each frame. */
-export interface Updateable {
-    /** Actions that should be executed after updating the component. */
-    onAfterUpdate: Event<any>;
-    /** Actions that should be executed before updating the component. */
-    onBeforeUpdate: Event<any>;
-    /**
-     * Function used to update the state of this component each frame. For
-     * instance, a renderer component will make a render each frame.
-     */
-    update(delta?: number): void;
-}
-/** Basic type to describe the progress of any kind of process. */
-export interface Progress {
-    /** The amount of things that have been done already. */
-    current: number;
-    /** The total amount of things to be done by the process. */
-    total: number;
-}
-/**
- * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
- */
-export interface Createable {
-    /** Creates a new instance of an element (e.g. a new Dimension). */
-    create: (data: any) => void;
-    /**
-     * Finish the creation process of the component, successfully creating an
-     * instance of whatever the component creates.
-     */
-    endCreation?: (data: any) => void;
-    /**
-     * Cancels the creation process of the component, going back to the state
-     * before starting to create.
+     * @throws Will throw an error if the renderer does not have an HTML container.
      */
-    cancelCreation?: (data: any) => void;
-    /** Deletes an existing instance of an element (e.g. a Dimension). */
-    delete: (data: any) => void;
+    setupEvents(active: boolean): void;
+    private resizeEvent;
+    private setupRenderer;
+    private onContextLost;
+    private onContextBack;
 }
-/**
- * Whether this component supports to be configured.
- */
-export interface Configurable<T, U> {
-    /** Wether this components has been already configured. */
-    isSetup: boolean;
-    /** Use the provided configuration to set up the tool. */
-    setup: (config?: Partial<U>) => void | Promise<void>;
-    /** Fired after successfully calling {@link Configurable.setup()}  */
-    readonly onSetup: Event<any>;
-    /** Object holding the tool configuration. You can edit this directly to change the object.
-     */
-    config: Required<T>;
+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;
 }
-/**
- * Whether a camera uses the Camera Controls library.
- */
-export interface CameraControllable {
-    /**
-     * An instance of CameraControls that provides camera control functionalities.
-     * This instance is used to manipulate the camera.
-     */
-    controls: CameraControls;
+export interface ViewpointPerspectiveCamera extends ViewpointCamera {
+    fov: number;
 }
-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 {
-    /**
-     * Whether this component is active or not. The behaviour can vary depending
-     * on the type of component. E.g. a disabled dimension tool will stop creating
-     * dimensions, while a disabled camera will stop moving. A disabled component
-     * will not be updated automatically each frame.
-     */
-    abstract enabled: boolean;
+export interface ViewpointOrthographicCamera extends ViewpointCamera {
+    viewToWorldScale: number;
 }
-import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
-import { Components } from "../../Components";
 /**
- * Base class of the library. Useful for finding out the interfaces something implements.
+ * Represents a viewpoint in a BCF file.
  */
-export declare abstract class Base {
-    components: Components;
-    constructor(components: Components);
-    /** Whether is component is {@link Disposable}. */
-    isDisposeable: () => this is Disposable;
-    /** Whether is component is {@link Resizeable}. */
-    isResizeable: () => this is Resizeable;
-    /** Whether is component is {@link Updateable}. */
-    isUpdateable: () => this is Updateable;
-    /** Whether is component is {@link Hideable}. */
-    isHideable: () => this is Hideable;
-    /** Whether is component is {@link Configurable}. */
-    isConfigurable: () => this is Configurable<any, any>;
+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 { Base } from "./base";
-import { World } from "./world";
-import { Event } from "./event";
+import * as THREE from "three";
+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";
 /**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
+ * 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 abstract class BaseWorldItem extends Base {
-    readonly worlds: Map<string, World>;
+export declare class Viewpoint implements BCFViewpoint {
+    title?: string;
+    readonly guid: string;
     /**
-     * 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").
+     * 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
      */
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
-    }>;
+    clippingPlanes: DataSet<SimplePlane>;
+    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
     /**
-     * The current world this item is associated with. It can be null if no world is currently active.
+     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
      */
-    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 {
+    readonly exceptionComponents: DataSet<string>;
     /**
-     * Whether the camera is enabled or not.
+     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
      */
-    abstract enabled: boolean;
+    readonly selectionComponents: DataSet<string>;
     /**
-     * The Three.js camera instance.
+     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
+     * For this to work, call viewpoint.colorize()
      */
-    abstract three: THREE.Camera;
+    readonly componentColors: DataMap<THREE.Color, string[]>;
     /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
+     * 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
      */
-    abstract controls?: CameraControls;
+    spacesVisible: boolean;
     /**
-     * Checks whether the instance is {@link CameraControllable}.
-     *
-     * @returns True if the instance is controllable, false otherwise.
+     * 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
      */
-    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>;
+    spaceBoundariesVisible: boolean;
     /**
-     * Abstract property representing the three.js object associated with this scene.
-     * It should be implemented by subclasses.
+     * 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
      */
-    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";
-import { BaseWorldItem } from "./base-world-item";
-import { Disposable, Resizeable, Updateable } from "./interfaces";
-/**
- * Abstract class representing a renderer for a 3D world. All renderers should use this class as a base.
- */
-export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
+    openingsVisible: boolean;
     /**
-     * The three.js WebGLRenderer instance associated with this renderer.
-     *
-     * @abstract
-     * @type {THREE.WebGLRenderer}
+     * When true, all components should be visible unless listed in the exceptions
+     * When false all components should be invisible unless listed in the exceptions
      */
-    abstract three: THREE.WebGLRenderer;
-    /** {@link Updateable.onBeforeUpdate} */
-    onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<undefined>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
+    defaultVisibility: boolean;
+    private get _selectionModelIdMap();
+    private get _exceptionModelIdMap();
     /**
-     * Event that fires when there has been a change to the list of clipping
-     * planes used by the active renderer.
+     * A list of components that should be selected (highlighted) when displaying a viewpoint.
+     * @returns The fragmentIdMap for components marked as selections.
      */
-    readonly onClippingPlanesUpdated: Event<unknown>;
-    /** {@link Updateable.update} */
-    abstract update(delta?: number): void | Promise<void>;
-    /** {@link Disposable.dispose} */
-    abstract dispose(): void;
-    /** {@link Resizeable.getSize} */
-    abstract getSize(): Vector2;
-    /** {@link Resizeable.resize} */
-    abstract resize(size: Vector2 | undefined): void;
+    get selection(): FRAGS.FragmentIdMap;
     /**
-     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
+     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
+     * @returns The fragmentIdMap for components marked as exceptions.
      */
-    clippingPlanes: THREE.Plane[];
+    get exception(): FRAGS.FragmentIdMap;
     /**
-     * Updates the clipping planes and triggers the 'onClippingPlanesUpdated' event.
+     * Retrieves the projection type of the viewpoint's camera.
      *
-     * @remarks
-     * This method is typically called when there is a change to the list of clipping planes
-     * used by the active renderer.
+     * @returns A string representing the projection type of the viewpoint's camera.
+     *          It can be either 'Perspective' or 'Orthographic'.
      */
-    updateClippingPlanes(): void;
+    get projection(): CameraProjection;
     /**
-     * Sets or removes a clipping plane from the renderer.
-     *
-     * @param active - A boolean indicating whether the clipping plane should be active or not.
-     * @param plane - The clipping plane to be added or removed.
-     * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to 'false'.
+     * Retrieves the position vector of the viewpoint's camera.
      *
      * @remarks
-     * This method adds or removes a clipping plane from the 'clippingPlanes' array.
-     * If 'active' is 'true' and the plane is not already in the array, it is added.
-     * If 'active' is 'false' and the plane is in the array, it is removed.
-     * The 'three.clippingPlanes' property is then updated to reflect the current state of the 'clippingPlanes' array,
-     * excluding any planes marked as local.
+     * 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.
      */
-    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): 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 {
+    get position(): THREE.Vector3;
     /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
+     * 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.
      */
-    meshes: Set<THREE.Mesh>;
+    get direction(): THREE.Vector3;
+    private _components;
     /**
-     * The base scene of the world.
+     * Represents the world in which the viewpoints are created and managed.
      */
-    scene: BaseScene;
+    readonly world: World;
+    private get _managerVersion();
     /**
-     * The base camera of the world.
+     * 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.
      */
-    camera: BaseCamera;
+    get topics(): import("../../../openbim/BCFTopics").Topic[];
+    constructor(components: Components, world: World, _config?: {
+        data?: Partial<BCFViewpoint>;
+        setCamera?: boolean;
+    });
     /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
+     * 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.
      */
-    renderer: BaseRenderer | null;
+    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
     /**
-     * A unique identifier for the world.
+     * 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.
      */
-    uuid: string;
+    set(data: Partial<BCFViewpoint>): this;
     /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     * 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.
      */
-    isDisposing: boolean;
-}
-import { Event } from "./event";
-/**
- * A class that extends the built-in Set class and provides additional functionality.
- * It triggers events when items are added, deleted, or the set is cleared.
- *
- * @template T - The type of elements in the set.
- */
-export declare class DataSet<T> extends Set<T> {
+    go(transition?: boolean): Promise<void>;
     /**
-     * An event that is triggered when a new item is added to the set.
+     * 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.
      */
-    readonly onItemAdded: Event<T>;
+    updateCamera(): void;
+    applyVisibility(): void;
     /**
-     * An event that is triggered when an item is deleted from the set.
+     * 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 '#'.
      */
-    readonly onItemDeleted: Event<unknown>;
+    applyColors(): void;
     /**
-     * An event that is triggered when the set is cleared.
+     * Resets the colors of all components in the viewpoint to their original color.
      */
-    readonly onCleared: Event<unknown>;
+    resetColors(): void;
+    private createComponentTags;
+    private createColorTags;
     /**
-     * Constructs a new instance of the DataSet class.
+     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
      *
-     * @param iterable - An optional iterable object to initialize the set with.
+     * @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.
      */
-    constructor(iterable?: Iterable<T> | null);
+    serialize(version?: string): Promise<string>;
+}
+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 {
     /**
-     * Clears the set and triggers the onCleared event.
+     * Whether the grid is visible or not.
      */
-    clear(): void;
+    visible: boolean;
     /**
-     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
-     *
-     * @param value - The value to add to the set.
-     * @returns - The set instance.
+     * The color of the grid lines.
      */
-    add(...value: T[]): this;
+    color: THREE.Color;
     /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
-     *
-     * @param value - The value to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
+     * The size of the primary grid lines.
      */
-    guard: (value: T) => boolean;
+    primarySize: number;
     /**
-     * Deletes a value from the set and triggers the onItemDeleted event.
-     *
-     * @param value - The value to delete from the set.
-     * @returns - True if the value was successfully deleted, false otherwise.
+     * The size of the secondary grid lines.
      */
-    delete(value: T): boolean;
+    secondarySize: number;
     /**
-     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
+     * The distance at which the grid lines start to fade away.
      */
-    dispose(): void;
+    distance: number;
 }
-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.
- *
- * @template K - The type of keys in the map.
- * @template V - The type of values in the map.
- */
-export declare class DataMap<K, V> extends Map<K, V> {
+export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
+    protected _config: SimpleGridConfigType;
     /**
-     * An event triggered when a new item is set in the map.
+     * Whether the grid is visible or not.
      */
-    readonly onItemSet: Event<{
-        key: K;
-        value: V;
-    }>;
+    get visible(): boolean;
     /**
-     * An event triggered when an existing item in the map is updated.
+     * Whether the grid is visible or not.
      */
-    readonly onItemUpdated: Event<{
-        key: K;
-        value: V;
-    }>;
+    set visible(value: boolean);
     /**
-     * An event triggered when an item is deleted from the map.
+     * The color of the grid lines.
      */
-    readonly onItemDeleted: Event<K>;
+    get color(): THREE.Color;
     /**
-     * An event triggered when the map is cleared.
+     * The color of the grid lines.
      */
-    readonly onCleared: Event<unknown>;
+    set color(value: THREE.Color);
     /**
-     * Constructs a new DataMap instance.
-     *
-     * @param iterable - An iterable object containing key-value pairs to populate the map.
+     * The size of the primary grid lines.
      */
-    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
+    get primarySize(): number;
     /**
-     * Clears the map and triggers the onCleared event.
+     * The size of the primary grid lines.
      */
-    clear(): void;
+    set primarySize(value: number);
     /**
-     * Sets the value for the specified key in the map and triggers the appropriate event (onItemSet or onItemUpdated).
-     *
-     * @param key - The key of the item to set.
-     * @param value - The value of the item to set.
-     * @returns The DataMap instance.
+     * The size of the secondary grid lines.
      */
-    set(key: K, value: V): this;
+    get secondarySize(): number;
     /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
-     *
-     * @param key - The key of the entry to be checked against the guard.
-     * @param value - The value of the entry to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
+     * The size of the secondary grid lines.
      */
-    guard: (key: K, value: V) => boolean;
+    set secondarySize(value: number);
     /**
-     * Deletes the specified key from the map and triggers the onItemDeleted event if the key was found.
-     *
-     * @param key - The key of the item to delete.
-     * @returns True if the key was found and deleted; otherwise, false.
+     * The distance at which the grid lines start to fade away.
      */
-    delete(key: K): boolean;
+    get distance(): number;
     /**
-     * Clears the map and resets the events.
-     */
-    dispose(): void;
-}
-import * as THREE from "three";
-export interface BooleanSettingsControl {
-    type: "Boolean";
-    value: boolean;
-}
-export interface ColorSettingsControl {
-    type: "Color";
-    value: THREE.Color;
-}
-export interface TextSettingsControl {
-    type: "Text";
-    value: string;
-}
-export interface NumberSettingControl {
-    type: "Number";
-    interpolable: boolean;
-    min?: number;
-    max?: number;
-    value: number;
-}
-export interface SelectSettingControl {
-    type: "Select";
-    multiple: boolean;
-    options: Set<string>;
-    value: string;
-}
-export interface Vector3SettingControl {
-    type: "Vector3";
-    value: THREE.Vector3;
-}
-export interface TextSetSettingControl {
-    type: "TextSet";
-    value: Set<string>;
-}
-export interface NoControl {
-    type: "None";
-    value: any;
-}
-export type ControlEntry = BooleanSettingsControl | ColorSettingsControl | TextSettingsControl | NumberSettingControl | SelectSettingControl | Vector3SettingControl | TextSetSettingControl | NoControl;
-export interface ControlsSchema {
-    [name: string]: ControlEntry | ControlsSchema;
+     * The distance at which the grid lines start to fade away.
+     */
+    set distance(value: number);
 }
-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[];
+export {};
+import * as THREE from "three";
+import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
+import { Components } from "../../Components";
+import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
+/**
+ * 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 { Hideable, Disposable, Event, World } from "../../Types";
@@ -4556,73 +4557,6 @@ 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";
 /**
@@ -4639,26 +4573,6 @@ export declare class OrbitMode implements NavigationMode {
     set(active: boolean): void;
     private activateOrbitControls;
 }
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
- */
-export declare class PlanMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Plan";
-    private mouseAction1?;
-    private mouseAction2?;
-    private mouseInitialized;
-    private readonly defaultAzimuthSpeed;
-    private readonly defaultPolarSpeed;
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-}
 import * as THREE from "three";
 import { CameraProjection } from "./types";
 import { Event } from "../../Types";
@@ -4704,6 +4618,26 @@ export declare class ProjectionManager {
     private getDistance;
     private setPerspectiveCamera;
 }
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
+ */
+export declare class PlanMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Plan";
+    private mouseAction1?;
+    private mouseAction2?;
+    private mouseInitialized;
+    private readonly defaultAzimuthSpeed;
+    private readonly defaultPolarSpeed;
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+}
 /**
  * The projection system of the camera.
  */
@@ -4730,6 +4664,73 @@ export interface NavigationMode {
     /** Whether this navigation mode is active or not. */
     enabled: boolean;
 }
+import * as THREE from "three";
+import { Event, World } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * A base renderer to determine visibility on screen.
+ */
+export declare class DistanceRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * Fires after making the visibility check to the meshes. It lists the
+     * meshes that are currently visible, and the ones that were visible
+     * just before but not anymore.
+     */
+    readonly onDistanceComputed: Event<number>;
+    /**
+     * Objects that won't be taken into account in the distance check.
+     */
+    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
+    /**
+     * Whether this renderer is active or not. If not, it won't render anything.
+     */
+    enabled: boolean;
+    /**
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
+     */
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /**
+     * The scene where the distance is computed.
+     */
+    scene: THREE.Scene;
+    /**
+     * The camera used to compute the distance.
+     */
+    camera: THREE.OrthographicCamera;
+    /**
+     * The material used to compute the distance.
+     */
+    depthMaterial: THREE.ShaderMaterial;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected readonly worker: Worker;
+    private _width;
+    private _height;
+    private readonly _postQuad;
+    private readonly tempRT;
+    private readonly resultRT;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    compute: () => Promise<void>;
+    private handleWorkerMessage;
+}
 /**
  * A rule for the {@link IfcFinder} to search items based on their category.
  */
@@ -4945,6 +4946,13 @@ export declare class IfcBasicQuery extends IfcFinderQuery {
     update(modelID: string, file: File): Promise<void>;
     protected findInLines(modelID: string, lines: string[]): void;
 }
+import { IfcRelName } from "./types";
+type IfcRelAttributePosition = {
+    related: number;
+    relating: number;
+};
+export declare const ifcRelAttrsPosition: Record<IfcRelName, IfcRelAttributePosition>;
+export {};
 import * as FRAGS from "@thatopen/fragments";
 import { IfcFinderQuery } from "./ifc-finder-query";
 import { IfcOperatorRule, IfcPropertyRule, SerializedQuery } from "./types";
@@ -4978,20 +4986,12 @@ export declare class IfcPropertyQuery extends IfcFinderQuery {
     /**
      * {@link IfcFinderQuery.update}
      */
-    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;
+    update(modelID: string, file: File): Promise<void>;
+    protected findInLines(modelID: string, lines: string[]): void;
 }
+import { IfcRelName } from "./types";
+import { IfcRelation } from "../../IfcRelationsIndexer";
+export declare const ifcRelClassNames: Record<IfcRelation, IfcRelName>;
 import * as THREE from "three";
 import * as WEBIFC from "web-ifc";
 import * as FRAGS from "@thatopen/fragments";
@@ -5007,60 +5007,43 @@ export declare class CivilReader {
     } | 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;
-}
+export type IfcRelationNames = [
+    "IfcRelAssignsToControl",
+    "IfcRelAssignsToGroup",
+    "IfcRelAssignsToProduct",
+    "IfcRelAssociatesClassification",
+    "IfcRelAssociatesMaterial",
+    "IfcRelAssociatesDocument",
+    "IfcRelContainedInSpatialStructure",
+    "IfcRelFlowControlElements",
+    "IfcRelConnectsElements",
+    "IfcRelDeclares",
+    "IfcRelAggregates",
+    "IfcRelNests",
+    "IfcRelDefinesByProperties",
+    "IfcRelDefinesByType",
+    "IfcRelDefinesByTemplate"
+];
+export type IfcRelName = IfcRelationNames[number];
 import * as WEBIFC from "web-ifc";
 export declare class IfcMetadataReader {
     getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
     getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
 }
+import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
- * A 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.
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
  */
-export interface StreamedAsset {
-    /** The unique identifier of the asset. */
-    id: number;
-    /** An array of geometries associated with the asset. */
-    geometries: {
-        /** The unique identifier of the geometry. */
-        geometryID: number;
-        /** The transformation matrix of the geometry as a number array. */
-        transformation: number[];
-        /** The color of the geometry as a number array. */
-        color: number[];
-    }[];
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    /**
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
+     */
+    propertiesSize: number;
 }
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createEntityFacets: (components: Components, elements: any) => IDSFacet[];
 import * as WEBIFC from "web-ifc";
 import * as THREE from "three";
 export declare class Units {
@@ -5071,6 +5054,12 @@ export declare class Units {
     private getLengthUnits;
     private getScaleMatrix;
 }
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createAttributeFacets: (components: Components, elements: any) => IDSFacet[];
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createClassificationFacets: (components: Components, elements: any) => IDSFacet[];
 export type IfcVersion = "IFC2X3" | "IFC4" | "IFC4X3_ADD2";
 export type IDSFacetParameterName = "Name" | "PredefinedType" | "Value" | "System" | "URI" | "PropertySet" | "BaseName" | "DataType" | "Value" | "Entity" | "Relation";
 export type IDSSimpleCardinality = "required" | "prohibited";
@@ -5110,188 +5099,56 @@ export interface IDSCheckResult {
     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 { 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 { 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;
-    serverAssignedId?: string;
-    type: string;
-    status: string;
+    cardinality: IDSConditionalCardinaltiy;
+}
+export interface IDSInfo {
     title: string;
-    priority?: string;
-    index?: number;
-    labels: Set<string>;
-    creationDate: Date;
-    creationAuthor: string;
-    modifiedDate?: Date;
-    modifiedAuthor?: string;
-    dueDate?: Date;
-    assignedTo?: string;
     description?: string;
-    stage?: string;
+    copyright?: string;
+    version?: string;
+    author?: string;
+    date?: Date;
+    purpose?: string;
+    milestone?: string;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { Components } from "../../../core/Components";
+import { DataSet } from "../../../core/Types";
+import { IDSCheckResult, IfcVersion } from "./types";
+import { IDSFacet } from "./facets";
+/**
+ * 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 { Components } from "../../../core/Components";
 import { Viewpoint } from "../../../core/Viewpoints";
@@ -5416,6 +5273,25 @@ export declare class Topic implements BCFTopic {
      */
     serialize(): string;
 }
+export type BCFVersion = "2.1" | "3";
+export interface BCFTopic {
+    guid: string;
+    serverAssignedId?: string;
+    type: string;
+    status: string;
+    title: string;
+    priority?: string;
+    index?: number;
+    labels: Set<string>;
+    creationDate: Date;
+    creationAuthor: string;
+    modifiedDate?: Date;
+    modifiedAuthor?: string;
+    dueDate?: Date;
+    assignedTo?: string;
+    description?: string;
+    stage?: string;
+}
 import { Topic } from "..";
 import { Viewpoint } from "../../../core/Viewpoints";
 import { Components } from "../../../core/Components";
@@ -5578,6 +5454,82 @@ export declare class BCFTopicsConfigManager extends Configurator<BCFTopics, BCFT
     set ignoreIncompleteTopicsOnImport(value: boolean);
 }
 export {};
+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];
+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 { BooleanSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
 import { CullerRenderer } from "../index";
@@ -5652,6 +5604,55 @@ export declare class CullerRendererConfigManager extends Configurator<CullerRend
     private resetInterval;
 }
 export {};
+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;
+}
+/**
+ * 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 FRAGS from "@thatopen/fragments";
 import { IDSCheckResult, IDSFacetParameter } from "../types";
 import { Components } from "../../../../core/Components";
@@ -5666,31 +5667,6 @@ 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 {
@@ -5747,6 +5723,31 @@ 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";
@@ -5805,6 +5806,8 @@ interface V2Schema {
 type RelationsMap = Map<number, Map<number, {
     [ifcRel: number]: number[];
 }>>;
+import { IDSFacetParameterName, IDSFacetParameter } from "../types";
+export declare const getParameterXML: (name: IDSFacetParameterName, parameter?: IDSFacetParameter) => string;
 import { IDSFacetParameter } from "../types";
 import { IDSFacet } from "./Facet";
 export declare class IdsMaterialFacet extends IDSFacet {
@@ -5839,7 +5842,5 @@ export declare class IDSPartOf extends IDSFacet {
     getEntities(model: FRAGS.FragmentsGroup, collector?: FRAGS.IfcProperties): Promise<number[]>;
     test(entities: FRAGS.IfcProperties, model: FRAGS.FragmentsGroup): Promise<import("../types").IDSCheckResult[]>;
 }
-import { IDSFacetParameterName, IDSFacetParameter } from "../types";
-export declare const getParameterXML: (name: IDSFacetParameterName, parameter?: IDSFacetParameter) => string;
 
 }