@thatopen/components 2.2.2 → 2.2.3

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.2.0-alpha.0";
+    static readonly release = "2.2.3";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
     /**
@@ -75,110 +75,6 @@ export declare class Components implements Disposable {
     private update;
     private static setupBVH;
 }
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
-/**
- * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * Return the UUIDs of all disposed components.
-     */
-    get(): Set<string>;
-    /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
-     *
-     * @param recursive - whether to recursively dispose the children of the mesh.
-     */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
-    /**
-     * Disposes a geometry from memory.
-     *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
-     */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}
-import { SimpleScene, SimpleSceneConfig } from "../Worlds";
-import { DistanceRenderer } from "./src";
-import { Disposable } from "../Types";
-/**
- * Configuration interface for the {@link ShadowedScene}. Defines properties for directional and ambient lights,
- * as well as shadows.
- */
-export interface ShadowedSceneConfig extends SimpleSceneConfig {
-    shadows: {
-        cascade: number;
-        resolution: number;
-    };
-}
-/**
- * A scene that supports efficient cast shadows. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/ShadowedScene). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/ShadowedScene).
- */
-export declare class ShadowedScene extends SimpleScene implements Disposable {
-    private _distanceRenderer?;
-    /**
-     * Whether the bias property should be set automatically depending on the shadow distance.
-     */
-    autoBias: boolean;
-    /**
-     * Configuration interface for the {@link ShadowedScene}.
-     * Defines properties for directional and ambient lights, as well as shadows.
-     */
-    config: Required<ShadowedSceneConfig>;
-    private _lightsWithShadow;
-    private _isComputingShadows;
-    private _shadowsEnabled;
-    private _bias;
-    /**
-     * The getter for the bias to prevent artifacts (stripes). It usually ranges between 0 and -0.005.
-     */
-    get bias(): number;
-    /**
-     * The setter for the bias to prevent artifacts (stripes). It usually ranges between 0 and -0.005.
-     */
-    set bias(value: number);
-    /**
-     * Getter to see whether the shadows are enabled or not in this scene instance.
-     */
-    get shadowsEnabled(): boolean;
-    /**
-     * Setter to control whether the shadows are enabled or not in this scene instance.
-     */
-    set shadowsEnabled(value: boolean);
-    /**
-     * Getter to get the renderer used to determine the farthest distance from the camera.
-     */
-    get distanceRenderer(): DistanceRenderer;
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<ShadowedSceneConfig>): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** Update all the shadows of the scene. */
-    updateShadows(): Promise<void>;
-    private recomputeShadows;
-}
 import { Component, Disposable, World, Event } from "../Types";
 import { SimpleRaycaster } from "./src";
 import { Components } from "../Components";
@@ -221,72 +117,50 @@ export declare class Raycasters extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
+import * as THREE from "three";
 import { Components } from "../Components";
-import { SimpleWorld } from "./src";
+import { Component } from "../Types";
 /**
- * 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).
+ * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
  */
-export declare class Worlds extends Component implements Updateable, Disposable {
+export declare class Disposer extends Component {
+    private _disposedComponents;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a new world is created.
-     * The event passes the newly created world as a parameter.
-     */
-    readonly onWorldCreated: Event<World>;
-    /**
-     * An event that is triggered when a world is deleted.
-     * The event passes the UUID of the deleted world as a parameter.
-     */
-    readonly onWorldDeleted: Event<string>;
-    /**
-     * A collection of worlds managed by this component.
-     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
-     */
-    list: Map<string, World>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
     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.
+     * Return the UUIDs of all disposed components.
      */
-    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
+    get(): Set<string>;
     /**
-     * Deletes a world from the list of worlds.
+     * Removes a mesh, its geometry and its materials from memory. If you are
+     * using any of these in other parts of the application, make sure that you
+     * remove them from the mesh before disposing it.
      *
-     * @param {World} world - The world to be deleted.
+     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
+     * to remove.
      *
-     * @throws {Error} - Throws an error if the provided world is not found in the list.
+     * @param materials - whether to dispose the materials of the mesh.
      *
-     * @returns {void}
+     * @param recursive - whether to recursively dispose the children of the mesh.
      */
-    delete(world: World): void;
+    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): 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.
+     * Disposes a geometry from memory.
      *
-     * @returns {void}
+     * @param geometry - the
+     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+     * to remove.
      */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(delta?: number): void | Promise<void>;
+    disposeGeometry(geometry: THREE.BufferGeometry): void;
+    private disposeGeometryAndMaterials;
+    private disposeChildren;
+    private static disposeMaterial;
 }
 import { Component, Disposable, World, Event } from "../Types";
 import { GridConfig, SimpleGrid } from "./src";
@@ -337,6 +211,65 @@ export declare class Grids extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
+import { SimpleScene, SimpleSceneConfig } from "../Worlds";
+import { DistanceRenderer } from "./src";
+import { Disposable } from "../Types";
+/**
+ * Configuration interface for the {@link ShadowedScene}. Defines properties for directional and ambient lights,
+ * as well as shadows.
+ */
+export interface ShadowedSceneConfig extends SimpleSceneConfig {
+    shadows: {
+        cascade: number;
+        resolution: number;
+    };
+}
+/**
+ * A scene that supports efficient cast shadows. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/ShadowedScene). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/ShadowedScene).
+ */
+export declare class ShadowedScene extends SimpleScene implements Disposable {
+    private _distanceRenderer?;
+    /**
+     * Whether the bias property should be set automatically depending on the shadow distance.
+     */
+    autoBias: boolean;
+    /**
+     * Configuration interface for the {@link ShadowedScene}.
+     * Defines properties for directional and ambient lights, as well as shadows.
+     */
+    config: Required<ShadowedSceneConfig>;
+    private _lightsWithShadow;
+    private _isComputingShadows;
+    private _shadowsEnabled;
+    private _bias;
+    /**
+     * The getter for the bias to prevent artifacts (stripes). It usually ranges between 0 and -0.005.
+     */
+    get bias(): number;
+    /**
+     * The setter for the bias to prevent artifacts (stripes). It usually ranges between 0 and -0.005.
+     */
+    set bias(value: number);
+    /**
+     * Getter to see whether the shadows are enabled or not in this scene instance.
+     */
+    get shadowsEnabled(): boolean;
+    /**
+     * Setter to control whether the shadows are enabled or not in this scene instance.
+     */
+    set shadowsEnabled(value: boolean);
+    /**
+     * Getter to get the renderer used to determine the farthest distance from the camera.
+     */
+    get distanceRenderer(): DistanceRenderer;
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<ShadowedSceneConfig>): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** Update all the shadows of the scene. */
+    updateShadows(): Promise<void>;
+    private recomputeShadows;
+}
 import * as THREE from "three";
 import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
 import { SimplePlane } from "./src";
@@ -525,24 +458,91 @@ export declare class Cullers extends Component implements Disposable {
      */
     updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
 }
-import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
+import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
 import { Components } from "../Components";
-import { BCFViewpoint, Viewpoint } from "./src";
+import { SimpleWorld } from "./src";
 /**
- * Configuration interface for the Viewpoints general behavior.
+ * 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).
  */
-interface ViewpointsConfig {
+export declare class Worlds extends Component implements Updateable, Disposable {
     /**
-     * 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
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    overwriteColors: boolean;
-}
-export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfig> {
-    static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
-    enabled: boolean;
-    /**
+    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * An event that is triggered when a new world is created.
+     * The event passes the newly created world as a parameter.
+     */
+    readonly onWorldCreated: Event<World>;
+    /**
+     * An event that is triggered when a world is deleted.
+     * The event passes the UUID of the deleted world as a parameter.
+     */
+    readonly onWorldDeleted: Event<string>;
+    /**
+     * A collection of worlds managed by this component.
+     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
+     */
+    list: Map<string, World>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
+     *
+     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
+     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
+     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
+     *
+     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
+     */
+    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
+    /**
+     * Deletes a world from the list of worlds.
+     *
+     * @param {World} world - The world to be deleted.
+     *
+     * @throws {Error} - Throws an error if the provided world is not found in the list.
+     *
+     * @returns {void}
+     */
+    delete(world: World): void;
+    /**
+     * Disposes of the Worlds component and all its managed worlds.
+     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
+     * and triggers the onDisposed event.
+     *
+     * @returns {void}
+     */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(delta?: number): void | Promise<void>;
+}
+import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
+import { Components } from "../Components";
+import { BCFViewpoint, Viewpoint } from "./src";
+/**
+ * Configuration interface for the Viewpoints general behavior.
+ */
+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;
+}
+export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfig> {
+    static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
+    enabled: boolean;
+    /**
      * A DataMap that stores Viewpoint instances, indexed by their unique identifiers (guid).
      * This map is used to manage and retrieve Viewpoint instances within the Viewpoints component.
      */
@@ -619,6 +619,111 @@ export declare class MiniMaps extends Component implements Updateable, Disposabl
     update(): void;
 }
 import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Represents an edge measurement result.
+ */
+export interface MeasureEdge {
+    /**
+     * The distance between the two points of the edge.
+     */
+    distance: number;
+    /**
+     * The two points that define the edge.
+     */
+    points: THREE.Vector3[];
+}
+/**
+ * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
+ */
+export declare class MeasurementUtils extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static uuid: string;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Utility method to calculate the distance from a point to a line segment.
+     *
+     * @param point - The point from which to calculate the distance.
+     * @param lineStart - The start point of the line segment.
+     * @param lineEnd - The end point of the line segment.
+     * @param clamp - If true, the distance will be clamped to the line segment's length.
+     * @returns The distance from the point to the line segment.
+     */
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    /**
+     * Method to get the face of a mesh that contains a given triangle index.
+     * It also returns the edges of the found face and their indices.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param triangleIndex - The index of the triangle within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
+     */
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    /**
+     * Method to get the vertices and normal of a mesh face at a given index.
+     * It also applies instance transformation if provided.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param faceIndex - The index of the face within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the vertices and normal of the face.
+     * @throws Will throw an error if the geometry is not indexed.
+     */
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    /**
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
+     *
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
+     */
+    round(vector: THREE.Vector3): void;
+    /**
+     * Calculates the volume of a set of fragments.
+     *
+     * @param frags - A map of fragment IDs to their corresponding item IDs.
+     * @returns The total volume of the fragments and the bounding sphere.
+     *
+     * @remarks
+     * This method creates a set of instanced meshes from the given fragments and item IDs.
+     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
+     *
+     * @throws Will throw an error if the geometry of the meshes is not indexed.
+     * @throws Will throw an error if the fragment manager is not available.
+     */
+    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    /**
+     * Calculates the total volume of a set of meshes.
+     *
+     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
+     * @returns The total volume of the meshes and the bounding sphere.
+     *
+     * @remarks
+     * This method calculates the volume of each mesh in the provided array and returns the total volume
+     * and its bounding sphere.
+     *
+     */
+    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
+    private getFaceData;
+    private getVolumeOfMesh;
+    private getSignedVolumeOfTriangle;
+}
+import * as THREE from "three";
 import { Components } from "../Components";
 import { SimpleCamera } from "..";
 import { NavigationMode, NavModeID, ProjectionManager } from "./src";
@@ -682,61 +787,195 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
     private newOrthoCamera;
     private setOrthoPerspCameraAspect;
 }
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Disposable, Event, Component, Components } from "../../core";
-import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
-export type { InverseAttribute, RelationsMap } from "./src/types";
-/**
- * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
- */
-export declare class IfcRelationsIndexer extends Component implements Disposable {
+import { XMLParser } from "fast-xml-parser";
+import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core/Types";
+import { BCFTopic, BCFTopicsConfig, Topic } from "./src";
+import { Viewpoint } from "../../core/Viewpoints";
+export declare class BCFTopics extends Component implements Disposable, Configurable<BCFTopicsConfig> {
+    static uuid: "de977976-e4f6-4e4f-a01a-204727839802";
+    enabled: boolean;
+    static xmlParser: XMLParser;
+    config: Required<BCFTopicsConfig>;
+    readonly list: DataMap<string, Topic>;
+    readonly onSetup: Event<unknown>;
+    isSetup: boolean;
+    setup(config?: Partial<BCFTopicsConfig>): void;
+    readonly onBCFImported: Event<Topic[]>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Creates a new BCFTopic instance and adds it to the list.
+     *
+     * @param data - Optional partial BCFTopic object to initialize the new topic with.
+     * If not provided, default values will be used.
+     * @returns The newly created BCFTopic instance.
      */
-    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    create(data?: Partial<BCFTopic>): Topic;
+    readonly onDisposed: Event<unknown>;
     /**
-     * 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.
+     * Disposes of the BCFTopics component and triggers the onDisposed event.
      *
-     * @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.
+     * @remarks
+     * This method clears the list of topics and triggers the onDisposed event.
+     * It also resets the onDisposed event listener.
      */
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
+    dispose(): void;
     /**
-     * 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.
+     * Retrieves the unique set of topic types used across all topics.
+     *
+     * @returns A Set containing the unique topic types.
      */
-    readonly relationMaps: ModelsRelationMap;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _relToAttributesMap;
-    private _inverseAttributes;
-    private _ifcRels;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    private indexRelations;
-    private getAttributeIndex;
+    get usedTypes(): Set<string>;
     /**
-     * Adds a relation map to the model's relations map.
-     *
-     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
-     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
+     * Retrieves the unique set of topic statuses used across all topics.
      *
-     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
+     * @returns A Set containing the unique topic statuses.
      */
-    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
+    get usedStatuses(): Set<string>;
+    /**
+     * Retrieves the unique set of topic priorities used across all topics.
+     *
+     * @returns A Set containing the unique topic priorities.
+     * Note: This method filters out any null or undefined priorities.
+     */
+    get usedPriorities(): Set<string | undefined>;
+    /**
+     * Retrieves the unique set of topic stages used across all topics.
+     *
+     * @returns A Set containing the unique topic stages.
+     * Note: This method filters out any null or undefined stages.
+     */
+    get usedStages(): Set<string | undefined>;
+    /**
+     * Retrieves the unique set of users associated with topics.
+     *
+     * @returns A Set containing the unique users.
+     * Note: This method collects users from the creation author, assigned to, modified author, and comment authors.
+     */
+    get usedUsers(): Set<string>;
+    /**
+     * Retrieves the unique set of labels used across all topics.
+     *
+     * @returns A Set containing the unique labels.
+     */
+    get usedLabels(): Set<string>;
+    /**
+     * Updates the set of extensions (types, statuses, priorities, labels, stages, users) based on the current topics.
+     * This method iterates through each topic in the list and adds its properties to the corresponding sets in the config.
+     */
+    updateExtensions(): void;
+    /**
+     * Updates the references to viewpoints in the topics.
+     * This function iterates through each topic and checks if the viewpoints exist in the viewpoints list.
+     * If a viewpoint does not exist, it is removed from the topic's viewpoints.
+     */
+    updateViewpointReferences(): void;
+    /**
+     * Exports the given topics to a BCF (Building Collaboration Format) zip file.
+     *
+     * @param topics - The topics to export. Defaults to all topics in the list.
+     * @returns A promise that resolves to a Blob containing the exported BCF zip file.
+     */
+    export(topics?: Iterable<Topic>): Promise<Blob>;
+    private serializeExtensions;
+    private processMarkupComment;
+    private getMarkupComments;
+    private getMarkupLabels;
+    private getMarkupViewpoints;
+    private getMarkupRelatedTopics;
+    /**
+     * Loads BCF (Building Collaboration Format) data into the engine.
+     *
+     * @param world - The default world where the viewpoints are going to be created.
+     * @param data - The BCF data to load.
+     *
+     * @returns A promise that resolves to an object containing the created viewpoints and topics.
+     *
+     * @throws An error if the BCF version is not supported.
+     */
+    load(data: Uint8Array, world: World): Promise<{
+        viewpoints: Viewpoint[];
+        topics: Topic[];
+    }>;
+}
+import * as WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
+ */
+export declare class IfcJsonExporter extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
+     */
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+}
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
+export type { InverseAttribute, RelationsMap } from "./src/types";
+/**
+ * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
+ */
+export declare class IfcRelationsIndexer extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * Event triggered when relations for a model have been indexed.
+     * This event provides the model's UUID and the relations map generated for that model.
+     *
+     * @property {string} modelID - The UUID of the model for which relations have been indexed.
+     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
+     * The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
+     */
+    readonly onRelationsIndexed: Event<{
+        modelID: string;
+        relationsMap: RelationsMap;
+    }>;
+    /**
+     * Holds the relationship mappings for each model processed by the indexer.
+     * The structure is a map where each key is a model's UUID, and the value is another map.
+     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
+     * representing a specific relation type, and the value is an array of expressIDs of entities
+     * that are related through that relation type. This structure allows for efficient querying
+     * of entity relationships within a model.
+     */
+    readonly relationMaps: ModelsRelationMap;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    private _relToAttributesMap;
+    private _inverseAttributes;
+    private _ifcRels;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    private indexRelations;
+    private getAttributeIndex;
+    /**
+     * Adds a relation map to the model's relations map.
+     *
+     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
+     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
+     *
+     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
+     */
+    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
     /**
      * Processes a given model to index its IFC entities relations based on predefined inverse attributes.
      * This method iterates through each specified inverse attribute, retrieves the corresponding relations,
@@ -858,31 +1097,6 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
 }
 import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
- */
-export declare class IfcJsonExporter extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
-     */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
-}
-import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Component, Disposable, Event, Components } from "../../core";
 /**
@@ -1150,167 +1364,62 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
     private newSingleProperty;
 }
 import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components } from "../../core";
+export declare function obbFromPoints(vertices: ArrayLike<number>): {
+    center: THREE.Vector3;
+    halfSizes: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    transformation: THREE.Matrix4;
+};
+export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
+import * as THREE from "three";
+import { Component, Components, Disposable, Event, World } from "../core";
 /**
- * Represents an edge measurement result.
+ * Configuration interface for the VertexPicker component.
  */
-export interface MeasureEdge {
+export interface VertexPickerConfig {
     /**
-     * The distance between the two points of the edge.
+     * If true, only vertices will be picked, not the closest point on the face.
      */
-    distance: number;
+    showOnlyVertex: boolean;
     /**
-     * The two points that define the edge.
+     * The maximum distance for snapping to a vertex.
      */
-    points: THREE.Vector3[];
+    snapDistance: number;
+    /**
+     * The HTML element to use for previewing the picked vertex.
+     */
+    previewElement: HTMLElement;
 }
 /**
- * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
+ * A class that provides functionality for picking vertices in a 3D scene.
  */
-export declare class MeasurementUtils extends Component {
+export declare class VertexPicker extends Component implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
      */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    readonly onVertexFound: Event<THREE.Vector3>;
     /**
-     * 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.
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
      */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    readonly onVertexLost: Event<THREE.Vector3>;
     /**
-     * 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.
+     * An event that is triggered when the picker is enabled or disabled
      */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
-     */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
-     *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
-     */
-    round(vector: THREE.Vector3): void;
-    /**
-     * Calculates the volume of a set of fragments.
-     *
-     * @param frags - A map of fragment IDs to their corresponding item IDs.
-     * @returns The total volume of the fragments and the bounding sphere.
-     *
-     * @remarks
-     * This method creates a set of instanced meshes from the given fragments and item IDs.
-     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
-     *
-     * @throws Will throw an error if the geometry of the meshes is not indexed.
-     * @throws Will throw an error if the fragment manager is not available.
-     */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
-    /**
-     * Calculates the total volume of a set of meshes.
-     *
-     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
-     * @returns The total volume of the meshes and the bounding sphere.
-     *
-     * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
-     *
-     */
-    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
-    private getFaceData;
-    private getVolumeOfMesh;
-    private getSignedVolumeOfTriangle;
-}
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
-import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
-}
-import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
-/**
- * Configuration interface for the VertexPicker component.
- */
-export interface VertexPickerConfig {
-    /**
-     * If true, only vertices will be picked, not the closest point on the face.
-     */
-    showOnlyVertex: boolean;
-    /**
-     * The maximum distance for snapping to a vertex.
-     */
-    snapDistance: number;
-    /**
-     * The HTML element to use for previewing the picked vertex.
-     */
-    previewElement: HTMLElement;
-}
-/**
- * A class that provides functionality for picking vertices in a 3D scene.
- */
-export declare class VertexPicker extends Component implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a vertex is found.
-     * The event passes a THREE.Vector3 representing the position of the found vertex.
-     */
-    readonly onVertexFound: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
-     */
-    readonly onVertexLost: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when the picker is enabled or disabled
-     */
-    readonly onEnabled: Event<boolean>;
+    readonly onEnabled: Event<boolean>;
     /**
      * A reference to the Components instance associated with this VertexPicker.
      */
@@ -1388,115 +1497,6 @@ export declare class VertexPicker extends Component implements Disposable {
     private getVertices;
     private getVertex;
 }
-import { XMLParser } from "fast-xml-parser";
-import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core/Types";
-import { BCFTopic, BCFTopicsConfig, Topic } from "./src";
-import { Viewpoint } from "../../core/Viewpoints";
-export declare class BCFTopics extends Component implements Disposable, Configurable<BCFTopicsConfig> {
-    static uuid: "de977976-e4f6-4e4f-a01a-204727839802";
-    enabled: boolean;
-    static xmlParser: XMLParser;
-    config: Required<BCFTopicsConfig>;
-    readonly list: DataMap<string, Topic>;
-    readonly onSetup: Event<unknown>;
-    isSetup: boolean;
-    setup(config?: Partial<BCFTopicsConfig>): void;
-    readonly onBCFImported: Event<Topic[]>;
-    /**
-     * Creates a new BCFTopic instance and adds it to the list.
-     *
-     * @param data - Optional partial BCFTopic object to initialize the new topic with.
-     * If not provided, default values will be used.
-     * @returns The newly created BCFTopic instance.
-     */
-    create(data?: Partial<BCFTopic>): Topic;
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Disposes of the BCFTopics component and triggers the onDisposed event.
-     *
-     * @remarks
-     * This method clears the list of topics and triggers the onDisposed event.
-     * It also resets the onDisposed event listener.
-     */
-    dispose(): void;
-    /**
-     * Retrieves the unique set of topic types used across all topics.
-     *
-     * @returns A Set containing the unique topic types.
-     */
-    get usedTypes(): Set<string>;
-    /**
-     * Retrieves the unique set of topic statuses used across all topics.
-     *
-     * @returns A Set containing the unique topic statuses.
-     */
-    get usedStatuses(): Set<string>;
-    /**
-     * Retrieves the unique set of topic priorities used across all topics.
-     *
-     * @returns A Set containing the unique topic priorities.
-     * Note: This method filters out any null or undefined priorities.
-     */
-    get usedPriorities(): Set<string | undefined>;
-    /**
-     * Retrieves the unique set of topic stages used across all topics.
-     *
-     * @returns A Set containing the unique topic stages.
-     * Note: This method filters out any null or undefined stages.
-     */
-    get usedStages(): Set<string | undefined>;
-    /**
-     * Retrieves the unique set of users associated with topics.
-     *
-     * @returns A Set containing the unique users.
-     * Note: This method collects users from the creation author, assigned to, modified author, and comment authors.
-     */
-    get usedUsers(): Set<string>;
-    /**
-     * Retrieves the unique set of labels used across all topics.
-     *
-     * @returns A Set containing the unique labels.
-     */
-    get usedLabels(): Set<string>;
-    /**
-     * Updates the set of extensions (types, statuses, priorities, labels, stages, users) based on the current topics.
-     * This method iterates through each topic in the list and adds its properties to the corresponding sets in the config.
-     */
-    updateExtensions(): void;
-    /**
-     * Updates the references to viewpoints in the topics.
-     * This function iterates through each topic and checks if the viewpoints exist in the viewpoints list.
-     * If a viewpoint does not exist, it is removed from the topic's viewpoints.
-     */
-    updateViewpointReferences(): void;
-    /**
-     * Exports the given topics to a BCF (Building Collaboration Format) zip file.
-     *
-     * @param topics - The topics to export. Defaults to all topics in the list.
-     * @returns A promise that resolves to a Blob containing the exported BCF zip file.
-     */
-    export(topics?: Iterable<Topic>): Promise<Blob>;
-    private serializeExtensions;
-    private processMarkupComment;
-    private getMarkupComments;
-    private getMarkupLabels;
-    private getMarkupViewpoints;
-    private getMarkupRelatedTopics;
-    /**
-     * Loads BCF (Building Collaboration Format) data into the engine.
-     *
-     * @param world - The default world where the viewpoints are going to be created.
-     * @param data - The BCF data to load.
-     *
-     * @returns A promise that resolves to an object containing the created viewpoints and topics.
-     *
-     * @throws An error if the BCF version is not supported.
-     */
-    load(data: Uint8Array, world: World): Promise<{
-        viewpoints: Viewpoint[];
-        topics: Topic[];
-    }>;
-}
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { FragmentsGroup } from "@thatopen/fragments";
@@ -1917,84 +1917,34 @@ export declare class Hider extends Component {
     isolate(items: FRAGS.FragmentIdMap): void;
     private updateCulledVisibility;
 }
-import { Component, Disposable, Event, Components } from "../../core";
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
 /**
- * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
+ * 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 Exploder 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: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    readonly onDisposed: Event<string>;
     /**
-     * The height of the explosion animation.
-     * This property determines the vertical distance by which fragments are moved during the explosion.
-     * Default value is 10.
+     * An event triggered when the IFC file starts loading.
      */
-    height: number;
+    readonly onIfcStartedLoading: Event<void>;
     /**
-     * The group name used for the explosion animation.
-     * This property specifies the group of fragments that will be affected by the explosion.
-     * Default value is "storeys".
+     * An event triggered when the setup process is completed.
      */
-    groupName: string;
+    readonly onSetup: Event<void>;
     /**
-     * A set of strings representing the exploded items.
-     * This set is used to keep track of which items have been exploded.
+     * The settings for the IfcLoader.
+     * It includes options for excluding categories, setting WASM paths, and more.
      */
-    list: Set<string>;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets the explosion state of the fragments.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the explosion.
-     *
-     * @remarks
-     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
-     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
-     * If 'active' is false, the fragments are moved back to their original position.
-     *
-     * The method also keeps track of the exploded items using the 'list' set.
-     *
-     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
-     */
-    set(active: boolean): void;
-}
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
-/**
- * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
- */
-export declare class IfcLoader extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * An event triggered when the IFC file starts loading.
-     */
-    readonly onIfcStartedLoading: Event<void>;
-    /**
-     * An event triggered when the setup process is completed.
-     */
-    readonly onSetup: Event<void>;
-    /**
-     * The settings for the IfcLoader.
-     * It includes options for excluding categories, setting WASM paths, and more.
-     */
-    settings: IfcFragmentSettings;
+    settings: IfcFragmentSettings;
     /**
      * The instance of the Web-IFC library used for handling IFC data.
      */
@@ -2082,6 +2032,56 @@ export declare class IfcLoader extends Component implements Disposable {
     private getGeometry;
     private autoSetWasm;
 }
+import { Component, Disposable, Event, Components } from "../../core";
+/**
+ * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
+ */
+export declare class Exploder extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * The height of the explosion animation.
+     * This property determines the vertical distance by which fragments are moved during the explosion.
+     * Default value is 10.
+     */
+    height: number;
+    /**
+     * The group name used for the explosion animation.
+     * This property specifies the group of fragments that will be affected by the explosion.
+     * Default value is "storeys".
+     */
+    groupName: string;
+    /**
+     * A set of strings representing the exploded items.
+     * This set is used to keep track of which items have been exploded.
+     */
+    list: Set<string>;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets the explosion state of the fragments.
+     *
+     * @param active - A boolean indicating whether to activate or deactivate the explosion.
+     *
+     * @remarks
+     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
+     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
+     * If 'active' is false, the fragments are moved back to their original position.
+     *
+     * The method also keeps track of the exploded items using the 'list' set.
+     *
+     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
+     */
+    set(active: boolean): void;
+}
 import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
@@ -2226,6 +2226,19 @@ export declare class FragmentsManager extends Component implements Disposable {
      */
     clone(model: FRAGS.FragmentsGroup, items?: FRAGS.FragmentIdMap): FragmentsGroup;
 }
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
+}
+/**
+ * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
+ */
+export declare const IfcCategoryMap: {
+    [key: number]: string;
+};
 /**
  * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
  *
@@ -2238,13 +2251,6 @@ export declare const IfcElements: {
     [key: number]: string;
 };
 import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}
-import * as WEBIFC from "web-ifc";
 import { Components, Disposable, Event, Component } from "../../core";
 import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
 /**
@@ -2407,12 +2413,6 @@ export declare class IfcPropertiesTiler extends Component implements Disposable
     private streamAllProperties;
     private cleanUp;
 }
-/**
- * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
- */
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
 import * as FRAGS from "@thatopen/fragments";
 export declare class IfcPropertiesUtils {
     static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
@@ -2438,6 +2438,10 @@ export declare class IfcPropertiesUtils {
     static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
     static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
 }
+/**
+ * A Set of unique numbers representing different types of IFC geometries.
+ */
+export declare const GeometryTypes: Set<number>;
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
 /**
@@ -2527,10 +2531,6 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     resize(size?: THREE.Vector2): void;
     private updatePlanes;
 }
-/**
- * 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, {
     forRelating: InverseAttribute;
@@ -2576,6 +2576,19 @@ export declare class Comment {
      */
     serialize(): string;
 }
+import * as FRAGS from "@thatopen/fragments";
+import * as WEBIFC from "web-ifc";
+export declare class SpatialIdsFinder {
+    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+}
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
+}
 import * as WEBIFC from "web-ifc";
 /** Configuration of the IFC-fragment conversion. */
 export declare class IfcFragmentSettings {
@@ -2619,19 +2632,6 @@ export declare class IfcFragmentSettings {
      */
     customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
 }
-import * as WEBIFC from "web-ifc";
-import { IfcItemsCategories } from "../../../ifc";
-export declare class SpatialStructure {
-    itemsByFloor: IfcItemsCategories;
-    private _units;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    cleanUp(): void;
-}
-import * as 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 THREE from "three";
 import { Hideable, Event, World, Disposable } from "../../Types";
 import { Components } from "../../Components";
@@ -2691,292 +2691,69 @@ export declare class SimpleGrid implements Hideable, Disposable {
     private setupEvents;
     private updateZoom;
 }
-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;
-}
-export interface BCFViewpoint {
-    title?: string;
-    guid: string;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
-    selectionComponents: Iterable<string>;
-    exceptionComponents: Iterable<string>;
-    clippingPlanes: DataSet<SimplePlane>;
-    spacesVisible: boolean;
-    spaceBoundariesVisible: boolean;
-    openingsVisible: boolean;
-    defaultVisibility: boolean;
-}
-import * as THREE from "three";
-import * 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";
-export declare class Viewpoint implements BCFViewpoint {
-    title?: string;
-    guid: string;
+/**
+ * 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> {
     /**
-     * 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.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    clippingPlanes: DataSet<SimplePlane>;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
+    add(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
     /**
-     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
      */
-    readonly exceptionComponents: DataSet<string>;
+    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> {
     /**
-     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    readonly selectionComponents: DataSet<string>;
+    add(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
     /**
-     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
-     * For this to work, call viewpoint.colorize()
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
      */
-    readonly componentColors: DataMap<string, string[]>;
-    /**
-     * Boolean flags to allow fine control over the visibility of spaces.
-     * A typical use of these flags is when DefaultVisibility=true but spaces should remain hidden.
-     * @default false
-     */
-    spacesVisible: boolean;
-    /**
-     * Boolean flags to allow fine control over the visibility of space boundaries.
-     * A typical use of these flags is when DefaultVisibility=true but space boundaries should remain hidden.
-     * @default false
-     */
-    spaceBoundariesVisible: boolean;
-    /**
-     * Boolean flags to allow fine control over the visibility of openings.
-     * A typical use of these flags is when DefaultVisibility=true but openings should remain hidden.
-     * @default false
-     */
-    openingsVisible: boolean;
-    /**
-     * When true, all components should be visible unless listed in the exceptions
-     * When false all components should be invisible unless listed in the exceptions
-     */
-    defaultVisibility: boolean;
-    private get _selectionModelIdMap();
-    private get _exceptionModelIdMap();
-    /**
-     * A list of components that should be selected (highlighted) when displaying a viewpoint.
-     * @returns The fragmentIdMap for components marked as selections.
-     */
-    get selection(): FRAGS.FragmentIdMap;
-    /**
-     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
-     * @returns The fragmentIdMap for components marked as exceptions.
-     */
-    get exception(): FRAGS.FragmentIdMap;
-    /**
-     * Retrieves the projection type of the viewpoint's camera.
-     *
-     * @returns A string representing the projection type of the viewpoint's camera.
-     *          It can be either 'Perspective' or 'Orthographic'.
-     */
-    get projection(): CameraProjection;
-    /**
-     * Retrieves the position vector of the viewpoint's camera.
-     *
-     * @remarks
-     * The position vector represents the camera's position in the world coordinate system.
-     * The function applies the base coordinate system transformation to the position vector.
-     *
-     * @returns A THREE.Vector3 representing the position of the viewpoint's camera.
-     */
-    get position(): THREE.Vector3;
-    /**
-     * Retrieves the direction vector of the viewpoint's camera.
-     *
-     * @remarks
-     * The direction vector represents the direction in which the camera is pointing.
-     * It is calculated by extracting the x, y, and z components from the camera's direction property.
-     *
-     * @returns A THREE.Vector3 representing the direction of the viewpoint's camera.
-     */
-    get direction(): THREE.Vector3;
-    private _components;
-    /**
-     * Represents the world in which the viewpoints are created and managed.
-     */
-    readonly world: World;
-    private get _managerVersion();
-    /**
-     * Retrieves the list of BCF topics associated with the current viewpoint.
-     *
-     * @remarks
-     * This function retrieves the BCFTopics manager from the components,
-     * then filters the list of topics to find those associated with the current viewpoint.
-     *
-     * @returns An array of BCF topics associated with the current viewpoint.
-     */
-    get topics(): import("../../../openbim/BCFTopics").Topic[];
-    constructor(components: Components, world: World, _config?: {
-        data?: Partial<BCFViewpoint>;
-        setCamera?: boolean;
-    });
-    /**
-     * Adds components to the viewpoint based on the provided fragment ID map.
-     *
-     * @param fragmentIdMap - A map containing fragment IDs as keys and arrays of express IDs as values.
-     *
-     * @returns A Promise that resolves when the components have been added to the viewpoint.
-     */
-    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): Promise<void>;
-    /**
-     * Sets 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.
-     *
-     * @param data - An object containing the properties to be set.
-     *               The properties not included in the object will remain unchanged.
-     *
-     * @returns The viewpoint instance with the updated properties.
-     */
-    set(data: Partial<BCFViewpoint>): this;
-    /**
-     * Sets the viewpoint of the camera in the world.
-     *
-     * @remarks
-     * This function calculates the target position based on the viewpoint information.
-     * It sets the visibility of the viewpoint components and then applies the viewpoint using the camera's controls.
-     *
-     * @param transition - Indicates whether the camera movement should have a transition effect.
-     *                      Default value is 'true'.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     *
-     * @returns A Promise that resolves when the camera has been set.
-     */
-    go(transition?: boolean): Promise<void>;
-    /**
-     * Updates the camera settings of the viewpoint based on the current world's camera and renderer.
-     *
-     * @remarks
-     * This function retrieves the camera's position, direction, and aspect ratio from the world's camera and renderer.
-     * It then calculates the camera's perspective or orthographic settings based on the camera type.
-     * Finally, it updates the viewpoint's camera settings and updates the viewpoint to the Viewpoints manager.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
-     */
-    updateCamera(): void;
-    /**
-     * 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 '#'.
-     */
-    colorize(): void;
-    /**
-     * Resets the colors of all components in the viewpoint to their original color.
-     * This method iterates through the 'componentColors' map, retrieves the fragment IDs
-     * corresponding to each color, and then uses the 'Classifier' to reset the color of those fragments.
-     */
-    resetColors(): void;
-    private createComponentTags;
-    /**
-     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
-     *
-     * @param version - The version of the BCF Manager to use for serialization.
-     *                   If not provided, the current version of the manager will be used.
-     *
-     * @returns A Promise that resolves to an XML string representing the viewpoint.
-     *          The XML string follows the BCF VisualizationInfo schema.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
-     */
-    serialize(version?: import("../../../openbim/BCFTopics").BCFVersion): Promise<string>;
-}
-/**
- * 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 {
+    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).
@@ -3091,25 +2868,6 @@ export declare abstract class Component extends Base {
      */
     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>;
-}
 import { Base } from "./base";
 import { World } from "./world";
 import { Event } from "./event";
@@ -3133,19 +2891,38 @@ export declare abstract class BaseWorldItem extends Base {
     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";
+import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
+import { Components } from "../../Components";
 /**
- * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
+ * Base class of the library. Useful for finding out the interfaces something implements.
  */
-export declare abstract class BaseCamera extends BaseWorldItem {
-    /**
-     * Whether the camera is enabled or not.
-     */
-    abstract enabled: boolean;
-    /**
+export declare abstract class Base {
+    components: Components;
+    constructor(components: Components);
+    /** Whether is component is {@link Disposable}. */
+    isDisposeable: () => this is Disposable;
+    /** Whether is component is {@link Resizeable}. */
+    isResizeable: () => this is Resizeable;
+    /** Whether is component is {@link Updateable}. */
+    isUpdateable: () => this is Updateable;
+    /** Whether is component is {@link Hideable}. */
+    isHideable: () => this is Hideable;
+    /** Whether is component is {@link Configurable}. */
+    isConfigurable: () => this is Configurable<any>;
+}
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { BaseWorldItem } from "./base-world-item";
+import { CameraControllable } from "./interfaces";
+/**
+ * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
+ */
+export declare abstract class BaseCamera extends BaseWorldItem {
+    /**
+     * Whether the camera is enabled or not.
+     */
+    abstract enabled: boolean;
+    /**
      * The Three.js camera instance.
      */
     abstract three: THREE.Camera;
@@ -3343,97 +3120,6 @@ export declare class DataSet<T> extends Set<T> {
      */
     dispose(): void;
 }
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { AsyncEvent, Event, World } from "../../Types";
-/**
- * Settings to configure the CullerRenderer.
- */
-export interface CullerRendererSettings {
-    /**
-     * Interval in milliseconds at which the visibility check should be performed.
-     * Default value is 1000.
-     */
-    updateInterval?: number;
-    /**
-     * Width of the render target used for visibility checks.
-     * Default value is 512.
-     */
-    width?: number;
-    /**
-     * Height of the render target used for visibility checks.
-     * Default value is 512.
-     */
-    height?: number;
-    /**
-     * Whether the visibility check should be performed automatically.
-     * Default value is true.
-     */
-    autoUpdate?: boolean;
-}
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class CullerRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * 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;
-    /**
-     * 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 world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected autoUpdate: boolean;
-    protected updateInterval: number;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _width;
-    private _height;
-    private _availableColor;
-    private readonly renderTarget;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * 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>;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-    private applySettings;
-}
 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.
@@ -3506,71 +3192,6 @@ export declare class DataMap<K, V> extends Map<K, V> {
     dispose(): void;
 }
 import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } 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>;
-    }>;
-    /**
-     * Pixels in screen a geometry must occupy to be considered "seen".
-     * Default value is 100.
-     */
-    threshold: number;
-    /**
-     * 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[]>>;
-    /**
-     * Flag to indicate if the renderer is currently processing.
-     * Used to prevent concurrent processing.
-     */
-    isProcessing: boolean;
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private _intervalID;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
-     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
-     */
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    /**
-     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
-     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
-     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
-     */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    /**
-     * Updates the given instanced meshes inside the culler. You should use this if you change the count property, e.g. when changing the visibility of fragments.
-     *
-     * @param meshes - The meshes to update.
-     *
-     * @returns {void}
-     */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
-}
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
-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.
@@ -3593,6 +3214,22 @@ export declare class Mouse implements Disposable {
     private updateMouseInfo;
     private setupEvents;
 }
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
+ */
+export declare class FirstPersonMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "FirstPerson";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
+}
 import * as THREE from "three";
 import { Components } from "../../Components";
 import { Event, World, Disposable } from "../../Types";
@@ -3623,106 +3260,436 @@ export declare class SimpleRaycaster implements Disposable {
     /** {@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}.
+     * Throws a ray from the camera to the mouse or touch event point and returns
+     * the first item found. This also takes into account the clipping planes
+     * used by the renderer.
+     *
+     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
+     * to query. If not provided, it will query all the meshes stored in
+     * {@link Components.meshes}.
+     */
+    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    /**
+     * Casts a ray from a given origin in a given direction and returns the first item found.
+     * This method also takes into account the clipping planes used by the renderer.
+     *
+     * @param origin - The origin of the ray.
+     * @param direction - The direction of the ray.
+     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
+     * @returns The first intersection found or 'null' if no intersection was found.
+     */
+    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
+    private intersect;
+    private filterClippingPlanes;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * 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 { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
+ */
+export declare class OrbitMode implements NavigationMode {
+    camera: OrthoPerspectiveCamera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
+}
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
+    /**
+     * Event that fires when the {@link CameraProjection} changes.
+     */
+    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+    /**
+     * Current projection mode of the camera.
+     * Default is "Perspective".
+     */
+    current: CameraProjection;
+    /**
+     * The camera controlled by this ProjectionManager.
+     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     */
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    private _component;
+    private _previousDistance;
+    constructor(camera: OrthoPerspectiveCamera);
+    /**
+     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     *
+     * @param projection - the new projection to set. If it is the current projection,
+     * it will have no effect.
+     */
+    set(projection: CameraProjection): Promise<void>;
+    /**
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
+     */
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getPerspectiveDims;
+    private setupOrthoCamera;
+    private getDistance;
+    private setPerspectiveCamera;
+}
+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;
+}
+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;
+}
+/**
+ * The projection system of the camera.
+ */
+export type CameraProjection = "Perspective" | "Orthographic";
+/**
+ * The extensible list of supported navigation modes.
+ */
+export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
+/**
+ * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ */
+export interface NavigationMode {
+    /** The unique ID of this navigation mode. */
+    id: NavModeID;
+    /**
+     * Enable or disable this navigation mode.
+     * When a new navigation mode is enabled, the previous navigation mode
+     * must be disabled.
+     *
+     * @param active - whether to enable or disable this mode.
+     * @param options - any additional data required to enable or disable it.
+     * */
+    set: (active: boolean, options?: any) => void;
+    /** Whether this navigation mode is active or not. */
+    enabled: boolean;
+}
+import * as THREE from "three";
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+/**
+ * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
+ *
+ * @template T - The type of the scene. Default is BaseScene.
+ * @template U - The type of the camera. Default is BaseCamera.
+ * @template S - The type of the renderer. Default is BaseRenderer.
+ */
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
+    /**
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
+     */
+    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
+     */
+    isDisposing: boolean;
+    /**
+     * Indicates whether the world is currently enabled.
+     * When disabled, the world will not be updated.
+     */
+    enabled: boolean;
+    /**
+     * A unique identifier for the world.
+     */
+    uuid: string;
+    /**
+     * An optional name for the world.
+     */
+    name?: string;
+    private _scene?;
+    private _camera?;
+    private _renderer;
+    /**
+     * Getter for the scene. If no scene is initialized, it throws an error.
+     * @returns The current scene.
+     */
+    get scene(): T;
+    /**
+     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
+     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
+     * @param scene - The new scene to be set.
+     */
+    set scene(scene: T);
+    /**
+     * Getter for the camera. If no camera is initialized, it throws an error.
+     * @returns The current camera.
+     */
+    get camera(): U;
+    /**
+     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
+     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
+     * @param camera - The new camera to be set.
+     */
+    set camera(camera: U);
+    /**
+     * Getter for the renderer.
+     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
+     */
+    get renderer(): S | null;
+    /**
+     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
+     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
+     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
+     * @param renderer - The new renderer to be set or null to remove the current renderer.
+     */
+    set renderer(renderer: S | null);
+    /** {@link Updateable.update} */
+    update(delta?: number): void;
+    /** {@link Disposable.dispose} */
+    dispose(disposeResources?: boolean): void;
+}
+import * as THREE from "three";
+import * 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";
+export declare class Viewpoint implements BCFViewpoint {
+    title?: string;
+    guid: string;
+    /**
+     * ClippingPlanes can be used to define a subsection of a building model that is related to the topic.
+     * Each clipping plane is defined by Location and Direction.
+     * The Direction vector points in the invisible direction meaning the half-space that is clipped.
+     */
+    clippingPlanes: DataSet<SimplePlane>;
+    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
+    /**
+     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
+     */
+    readonly exceptionComponents: DataSet<string>;
+    /**
+     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
+     */
+    readonly selectionComponents: DataSet<string>;
+    /**
+     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
+     * For this to work, call viewpoint.colorize()
+     */
+    readonly componentColors: DataMap<string, string[]>;
+    /**
+     * Boolean flags to allow fine control over the visibility of spaces.
+     * A typical use of these flags is when DefaultVisibility=true but spaces should remain hidden.
+     * @default false
+     */
+    spacesVisible: boolean;
+    /**
+     * Boolean flags to allow fine control over the visibility of space boundaries.
+     * A typical use of these flags is when DefaultVisibility=true but space boundaries should remain hidden.
+     * @default false
+     */
+    spaceBoundariesVisible: boolean;
+    /**
+     * Boolean flags to allow fine control over the visibility of openings.
+     * A typical use of these flags is when DefaultVisibility=true but openings should remain hidden.
+     * @default false
+     */
+    openingsVisible: boolean;
+    /**
+     * When true, all components should be visible unless listed in the exceptions
+     * When false all components should be invisible unless listed in the exceptions
+     */
+    defaultVisibility: boolean;
+    private get _selectionModelIdMap();
+    private get _exceptionModelIdMap();
+    /**
+     * A list of components that should be selected (highlighted) when displaying a viewpoint.
+     * @returns The fragmentIdMap for components marked as selections.
+     */
+    get selection(): FRAGS.FragmentIdMap;
+    /**
+     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
+     * @returns The fragmentIdMap for components marked as exceptions.
      */
-    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    get exception(): FRAGS.FragmentIdMap;
     /**
-     * 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.
+     * Retrieves the projection type of the viewpoint's camera.
      *
-     * @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.
+     * @returns A string representing the projection type of the viewpoint's camera.
+     *          It can be either 'Perspective' or 'Orthographic'.
      */
-    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";
-/**
- * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
- *
- * @template T - The type of the scene. Default is BaseScene.
- * @template U - The type of the camera. Default is BaseCamera.
- * @template S - The type of the renderer. Default is BaseRenderer.
- */
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
+    get projection(): CameraProjection;
     /**
-     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
+     * Retrieves the position vector of the viewpoint's camera.
+     *
+     * @remarks
+     * The position vector represents the camera's position in the world coordinate system.
+     * The function applies the base coordinate system transformation to the position vector.
+     *
+     * @returns A THREE.Vector3 representing the position of the viewpoint's camera.
      */
-    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    get position(): THREE.Vector3;
     /**
-     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
+     * 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.
      */
-    isDisposing: boolean;
+    get direction(): THREE.Vector3;
+    private _components;
     /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
+     * Represents the world in which the viewpoints are created and managed.
      */
-    enabled: boolean;
+    readonly world: World;
+    private get _managerVersion();
     /**
-     * A unique identifier for 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.
      */
-    uuid: string;
+    get topics(): import("../../../openbim/BCFTopics").Topic[];
+    constructor(components: Components, world: World, _config?: {
+        data?: Partial<BCFViewpoint>;
+        setCamera?: boolean;
+    });
     /**
-     * An optional name for the world.
+     * 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.
+     *
+     * @returns A Promise that resolves when the components have been added to the viewpoint.
      */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
+    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): Promise<void>;
     /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
+     * Sets 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.
+     *
+     * @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.
      */
-    get scene(): T;
+    set(data: Partial<BCFViewpoint>): this;
     /**
-     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
-     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
-     * @param scene - The new scene to be set.
+     * 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.
      */
-    set scene(scene: T);
+    go(transition?: boolean): Promise<void>;
     /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
+     * 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.
      */
-    get camera(): U;
+    updateCamera(): void;
     /**
-     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
-     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
-     * @param camera - The new camera to be set.
+     * 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 '#'.
      */
-    set camera(camera: U);
+    colorize(): void;
     /**
-     * Getter for the renderer.
-     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
+     * Resets the colors of all components in the viewpoint to their original color.
+     * This method iterates through the 'componentColors' map, retrieves the fragment IDs
+     * corresponding to each color, and then uses the 'Classifier' to reset the color of those fragments.
      */
-    get renderer(): S | null;
+    resetColors(): void;
+    private createComponentTags;
     /**
-     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
-     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
-     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
-     * @param renderer - The new renderer to be set or null to remove the current renderer.
+     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
+     *
+     * @param version - The version of the BCF Manager to use for serialization.
+     *                   If not provided, the current version of the manager will be used.
+     *
+     * @returns A Promise that resolves to an XML string representing the viewpoint.
+     *          The XML string follows the BCF VisualizationInfo schema.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     * @throws An error if the world's renderer is not available.
      */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
-    /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
+    serialize(version?: import("../../../openbim/BCFTopics").BCFVersion): Promise<string>;
 }
 import * as THREE from "three";
 import { BaseScene, Configurable, Event } from "../../Types";
@@ -3843,41 +3810,132 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
     three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
     private _allControls;
     /**
-     * The object that controls the camera. An instance of
-     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
-     * Transforming the camera directly will have no effect: you need to use this
-     * object to move, rotate, look at objects, etc.
+     * The object that controls the camera. An instance of
+     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
+     * Transforming the camera directly will have no effect: you need to use this
+     * object to move, rotate, look at objects, etc.
+     */
+    get controls(): CameraControls;
+    /**
+     * Getter for the enabled state of the camera controls.
+     * If the current world is null, it returns false.
+     * Otherwise, it returns the enabled state of the camera controls.
+     *
+     * @returns {boolean} The enabled state of the camera controls.
+     */
+    get enabled(): boolean;
+    /**
+     * Setter for the enabled state of the camera controls.
+     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
+     *
+     * @param {boolean} enabled - The new enabled state of the camera controls.
+     */
+    set enabled(enabled: boolean);
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(_delta: number): void;
+    /**
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
+     */
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
+}
+import * as THREE from "three";
+import { Components } from "../../Components";
+import { AsyncEvent, Event, World } from "../../Types";
+/**
+ * Settings to configure the CullerRenderer.
+ */
+export interface CullerRendererSettings {
+    /**
+     * Interval in milliseconds at which the visibility check should be performed.
+     * Default value is 1000.
+     */
+    updateInterval?: number;
+    /**
+     * Width of the render target used for visibility checks.
+     * Default value is 512.
+     */
+    width?: number;
+    /**
+     * Height of the render target used for visibility checks.
+     * Default value is 512.
+     */
+    height?: number;
+    /**
+     * Whether the visibility check should be performed automatically.
+     * Default value is true.
+     */
+    autoUpdate?: boolean;
+}
+/**
+ * A base renderer to determine visibility on screen.
+ */
+export declare class CullerRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * 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.
      */
-    get controls(): CameraControls;
+    enabled: boolean;
     /**
-     * Getter for the enabled state of the camera controls.
-     * If the current world is null, it returns false.
-     * Otherwise, it returns the enabled state of the camera controls.
-     *
-     * @returns {boolean} The enabled state of the camera controls.
+     * Needs to check whether there are objects that need to be hidden or shown.
+     * You can bind this to the camera movement, to a certain interval, etc.
      */
-    get enabled(): boolean;
+    needsUpdate: boolean;
     /**
-     * Setter for the enabled state of the camera controls.
-     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
-     *
-     * @param {boolean} enabled - The new enabled state of the camera controls.
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
      */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected autoUpdate: boolean;
+    protected updateInterval: number;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _width;
+    private _height;
+    private _availableColor;
+    private readonly renderTarget;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
     /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
      */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
+    updateVisibility: (force?: boolean) => Promise<void>;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
+    private applySettings;
 }
 import * as THREE from "three";
 import { Event, World } from "../../Types";
@@ -3946,128 +4004,70 @@ export declare class DistanceRenderer {
     compute: () => Promise<void>;
     private handleWorkerMessage;
 }
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
- */
-export declare class OrbitMode implements NavigationMode {
-    camera: OrthoPerspectiveCamera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Orbit";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private activateOrbitControls;
-}
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
- */
-export declare class FirstPersonMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "FirstPerson";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private setupFirstPersonCamera;
-}
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
- */
-export declare class PlanMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Plan";
-    private mouseAction1?;
-    private mouseAction2?;
-    private mouseInitialized;
-    private readonly defaultAzimuthSpeed;
-    private readonly defaultPolarSpeed;
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-}
-/**
- * The projection system of the camera.
- */
-export type CameraProjection = "Perspective" | "Orthographic";
-/**
- * The extensible list of supported navigation modes.
- */
-export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
-/**
- * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
- */
-export interface NavigationMode {
-    /** The unique ID of this navigation mode. */
-    id: NavModeID;
-    /**
-     * Enable or disable this navigation mode.
-     * When a new navigation mode is enabled, the previous navigation mode
-     * must be disabled.
-     *
-     * @param active - whether to enable or disable this mode.
-     * @param options - any additional data required to enable or disable it.
-     * */
-    set: (active: boolean, options?: any) => void;
-    /** Whether this navigation mode is active or not. */
-    enabled: boolean;
-}
+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 { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
 /**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
  */
-export declare class ProjectionManager {
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
-     * Event that fires when the {@link CameraProjection} changes.
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
      */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
     /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
      */
-    current: CameraProjection;
+    threshold: number;
     /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     * Map of color code to THREE.InstancedMesh.
+     * Used to keep track of color-coded meshes.
      */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    constructor(camera: OrthoPerspectiveCamera);
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /**
-     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
-     *
-     * @param projection - the new projection to set. If it is the current projection,
-     * it will have no effect.
+     * Flag to indicate if the renderer is currently processing.
+     * Used to prevent concurrent processing.
      */
-    set(projection: CameraProjection): Promise<void>;
+    isProcessing: boolean;
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private _intervalID;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
+     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
+     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
      */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    /**
+     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
+     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
+     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
+     */
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    /**
+     * 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 { Hideable, Disposable, Event, World } from "../../Types";
@@ -4413,6 +4413,16 @@ export declare class IfcMetadataReader {
     getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
     getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
 }
+import * as WEBIFC from "web-ifc";
+import * as THREE from "three";
+export declare class Units {
+    factor: number;
+    complement: number;
+    apply(matrix: THREE.Matrix4): void;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    private getLengthUnits;
+    private getScaleMatrix;
+}
 import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
  * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
@@ -4458,23 +4468,8 @@ export interface StreamedAsset {
         color: number[];
     }[];
 }
-import * as WEBIFC from "web-ifc";
-import * as THREE from "three";
-export declare class Units {
-    factor: number;
-    complement: number;
-    apply(matrix: THREE.Matrix4): void;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    private getLengthUnits;
-    private getScaleMatrix;
-}
 import { BCFTopics } from "../..";
 export declare const extensionsImporter: (manager: BCFTopics, extensionsXML: string) => void;
-import { BufferGeometry } from "three";
-import * as THREE from "three";
-export declare class TransformHelper {
-    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
-}
 import * as WEBIFC from "web-ifc";
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
@@ -4546,6 +4541,11 @@ export type IfcRelations = [
     typeof WEBIFC.IFCRELNESTS
 ];
 export type IfcRelation = IfcRelations[number];
+import { BufferGeometry } from "three";
+import * as THREE from "three";
+export declare class TransformHelper {
+    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
+}
 import * as WEBIFC from "web-ifc";
 import { IfcSchema } from "@thatopen/fragments";
 import { IfcRelName } from "./types";