@thatopen/components 2.2.0-alpha.1 → 2.2.0

package/dist/namespace.d.ts

@@ -381,44 +381,6 @@ export declare class Classifier extends Component implements Disposable {
     resetColor(items: FRAGS.FragmentIdMap): void;
     protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
 }
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
-/**
- * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
- */
-export declare class Hider extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Sets the visibility of fragments within the 3D scene.
-     * If no 'items' parameter is provided, all fragments will be set to the specified visibility.
-     * If 'items' is provided, only the specified fragments will be affected.
-     *
-     * @param visible - The visibility state to set for the fragments.
-     * @param items - An optional map of fragment IDs and their corresponding sub-fragment IDs to be affected.
-     * If not provided, all fragments will be affected.
-     *
-     * @returns {void}
-     */
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
-    /**
-     * Isolates fragments within the 3D scene by hiding all other fragments and showing only the specified ones.
-     * It calls the 'set' method twice: first to hide all fragments, and then to show only the specified ones.
-     *
-     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
-     * If not provided, all fragments will be isolated.
-     *
-     * @returns {void}
-     */
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
-}
 import { Component, Disposable, Event, Components } from "../../core";
 /**
  * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
@@ -469,6 +431,44 @@ export declare class Exploder extends Component implements Disposable {
      */
     set(active: boolean): void;
 }
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
+/**
+ * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
+ */
+export declare class Hider extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Sets the visibility of fragments within the 3D scene.
+     * If no 'items' parameter is provided, all fragments will be set to the specified visibility.
+     * If 'items' is provided, only the specified fragments will be affected.
+     *
+     * @param visible - The visibility state to set for the fragments.
+     * @param items - An optional map of fragment IDs and their corresponding sub-fragment IDs to be affected.
+     * If not provided, all fragments will be affected.
+     *
+     * @returns {void}
+     */
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    /**
+     * Isolates fragments within the 3D scene by hiding all other fragments and showing only the specified ones.
+     * It calls the 'set' method twice: first to hide all fragments, and then to show only the specified ones.
+     *
+     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
+     * If not provided, all fragments will be isolated.
+     *
+     * @returns {void}
+     */
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
+}
 import * as WEBIFC from "web-ifc";
 import * as FRAGS from "@thatopen/fragments";
 import { IfcFragmentSettings } from "./src";
@@ -1417,23 +1417,51 @@ export declare class Cullers extends Component implements Disposable {
      */
     updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
 }
-import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
+import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
+import { Components } from "../Components";
+import { BCFViewpoint, Viewpoint } from "./src";
+/**
+ * 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 UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
+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.
+     */
+    readonly list: DataMap<string, Viewpoint>;
+    /**
+     * Creates a new Viewpoint instance and adds it to the list.
+     *
+     * @param world - The world in which the Viewpoint will be created.
+     * @param data - Optional partial data for the Viewpoint. If not provided, default data will be used.
+     *
+     * @returns The newly created Viewpoint instance.
+     */
+    create(world: World, data?: Partial<BCFViewpoint>): Viewpoint;
+    constructor(components: Components);
+    isSetup: boolean;
+    setup(): void;
+    onSetup: Event<unknown>;
+    config: Required<ViewpointsConfig>;
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Disposes of the Viewpoints component and its associated resources.
+     *
+     * This method is responsible for cleaning up any resources held by the Viewpoints component,
+     * such as disposing of the DataMap of Viewpoint instances and triggering and resetting the
+     * onDisposed event.
+     */
+    dispose(): void;
 }
 import { MiniMap } from "./src";
 import { Component, Updateable, World, Event, Disposable } from "../Types";
@@ -1483,122 +1511,6 @@ export declare class MiniMaps extends Component implements Updateable, Disposabl
     update(): void;
 }
 import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
-/**
- * Configuration interface for the VertexPicker component.
- */
-export interface VertexPickerConfig {
-    /**
-     * If true, only vertices will be picked, not the closest point on the face.
-     */
-    showOnlyVertex: boolean;
-    /**
-     * The maximum distance for snapping to a vertex.
-     */
-    snapDistance: number;
-    /**
-     * The HTML element to use for previewing the picked vertex.
-     */
-    previewElement: HTMLElement;
-}
-/**
- * A class that provides functionality for picking vertices in a 3D scene.
- */
-export declare class VertexPicker extends Component implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a vertex is found.
-     * The event passes a THREE.Vector3 representing the position of the found vertex.
-     */
-    readonly onVertexFound: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
-     */
-    readonly onVertexLost: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when the picker is enabled or disabled
-     */
-    readonly onEnabled: Event<boolean>;
-    /**
-     * A reference to the Components instance associated with this VertexPicker.
-     */
-    components: Components;
-    /**
-     * A reference to the working plane used for vertex picking.
-     * This plane is used to determine which vertices are considered valid for picking.
-     * If this value is null, all vertices are considered valid.
-     */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
-    /**
-     * Sets the enabled state of the VertexPicker.
-     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
-     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
-     *
-     * @param value - The new enabled state.
-     */
-    set enabled(value: boolean);
-    /**
-     * Gets the current enabled state of the VertexPicker.
-     *
-     * @returns The current enabled state.
-     */
-    get enabled(): boolean;
-    /**
-     * Sets the configuration for the VertexPicker component.
-     *
-     * @param value - A Partial object containing the configuration properties to update.
-     * The properties not provided in the value object will retain their current values.
-     *
-     * @example
-     * '''typescript
-     * vertexPicker.config = {
-     *   snapDistance: 0.5,
-     *   showOnlyVertex: true,
-     * };
-     * '''
-     */
-    set config(value: Partial<VertexPickerConfig>);
-    /**
-     * Gets the current configuration for the VertexPicker component.
-     *
-     * @returns A copy of the current VertexPickerConfig object.
-     *
-     * @example
-     * '''typescript
-     * const currentConfig = vertexPicker.config;
-     * console.log(currentConfig.snapDistance); // Output: 0.25
-     * '''
-     */
-    get config(): Partial<VertexPickerConfig>;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Performs the vertex picking operation based on the current state of the VertexPicker.
-     *
-     * @param world - The World instance to use for raycasting.
-     *
-     * @returns The current picked point, or null if no point is picked.
-     *
-     * @remarks
-     * This method checks if the VertexPicker is enabled. If not, it returns the current picked point.
-     * If enabled, it performs raycasting to find the closest intersecting object.
-     * It then determines the closest vertex or point on the face, based on the configuration settings.
-     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
-     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
-     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
-     */
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
-}
-import * as THREE from "three";
 import { Components } from "../Components";
 import { SimpleCamera } from "..";
 import { NavigationMode, NavModeID, ProjectionManager } from "./src";
@@ -1662,42 +1574,16 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
     private newOrthoCamera;
     private setOrthoPerspCameraAspect;
 }
-import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
-import { Components } from "../Components";
-import { BCFViewpoint, Viewpoint } from "./src";
+import * as WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
 /**
- * Configuration interface for the Viewpoints general behavior.
+ * 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).
  */
-interface ViewpointsConfig {
+export declare class IfcJsonExporter extends Component {
     /**
-     * Indicates whether to overwrite the fragments colors when applying viewpoints.
-     * @default false
-     */
-    overwriteColors: boolean;
-}
-export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfig> {
-    static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
-    enabled: boolean;
-    readonly list: DataMap<string, Viewpoint>;
-    create(world: World, data?: Partial<BCFViewpoint>): Viewpoint;
-    constructor(components: Components);
-    isSetup: boolean;
-    setup(): void;
-    onSetup: Event<unknown>;
-    config: Required<ViewpointsConfig>;
-    readonly onDisposed: Event<unknown>;
-    dispose(): void;
-}
-import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
- */
-export declare class IfcJsonExporter extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * 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} */
@@ -1713,6 +1599,13 @@ export declare class IfcJsonExporter extends Component {
      */
     export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
+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 WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Disposable, Event, Component, Components } from "../../core";
@@ -2001,7 +1894,7 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
      */
     static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
     /**
-     * Method to set properties data in the model.
+     * Method to add or update entity attributes in the model.
      *
      * @param model - The FragmentsGroup model in which to set the properties.
      * @param dataToSave - An array of objects representing the properties to be saved.
@@ -2123,6 +2016,17 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
      * @throws Will throw an error if any issues occur during the saving process.
      */
     saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Retrieves all the entities of a specific type from the model and returns their express IDs wrapped in Handles.
+     * This is used to make references of an entity inside another entity attributes.
+     *
+     * @param model - The FragmentsGroup model from which to retrieve the entities.
+     * @param type - The type of the entities to retrieve. This should be the express ID of the IFC type.
+     *
+     * @returns A promise that resolves with an array of Handles, each containing the express ID of an entity of the specified type.
+     * @returns null if the model doesn't have any entity of that type
+     */
+    getEntityRef(model: FragmentsGroup, type: number): Promise<WEBIFC.Handle<unknown>[] | null>;
     /**
      * Sets an attribute listener for a specific attribute of an entity in the model.
      * The listener will trigger an event whenever the attribute's value changes.
@@ -2145,6 +2049,133 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
     private newSingleProperty;
 }
 import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
+import * as THREE from "three";
+import { Component, Components, Disposable, Event, World } from "../core";
+/**
+ * Configuration interface for the VertexPicker component.
+ */
+export interface VertexPickerConfig {
+    /**
+     * If true, only vertices will be picked, not the closest point on the face.
+     */
+    showOnlyVertex: boolean;
+    /**
+     * The maximum distance for snapping to a vertex.
+     */
+    snapDistance: number;
+    /**
+     * The HTML element to use for previewing the picked vertex.
+     */
+    previewElement: HTMLElement;
+}
+/**
+ * A class that provides functionality for picking vertices in a 3D scene.
+ */
+export declare class VertexPicker extends Component implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
+     */
+    readonly onVertexFound: Event<THREE.Vector3>;
+    /**
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
+     */
+    readonly onVertexLost: Event<THREE.Vector3>;
+    /**
+     * An event that is triggered when the picker is enabled or disabled
+     */
+    readonly onEnabled: Event<boolean>;
+    /**
+     * A reference to the Components instance associated with this VertexPicker.
+     */
+    components: Components;
+    /**
+     * A reference to the working plane used for vertex picking.
+     * This plane is used to determine which vertices are considered valid for picking.
+     * If this value is null, all vertices are considered valid.
+     */
+    workingPlane: THREE.Plane | null;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
+    /**
+     * Sets the enabled state of the VertexPicker.
+     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
+     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
+     *
+     * @param value - The new enabled state.
+     */
+    set enabled(value: boolean);
+    /**
+     * Gets the current enabled state of the VertexPicker.
+     *
+     * @returns The current enabled state.
+     */
+    get enabled(): boolean;
+    /**
+     * Sets the configuration for the VertexPicker component.
+     *
+     * @param value - A Partial object containing the configuration properties to update.
+     * The properties not provided in the value object will retain their current values.
+     *
+     * @example
+     * '''typescript
+     * vertexPicker.config = {
+     *   snapDistance: 0.5,
+     *   showOnlyVertex: true,
+     * };
+     * '''
+     */
+    set config(value: Partial<VertexPickerConfig>);
+    /**
+     * Gets the current configuration for the VertexPicker component.
+     *
+     * @returns A copy of the current VertexPickerConfig object.
+     *
+     * @example
+     * '''typescript
+     * const currentConfig = vertexPicker.config;
+     * console.log(currentConfig.snapDistance); // Output: 0.25
+     * '''
+     */
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
+     *
+     * @param world - The World instance to use for raycasting.
+     *
+     * @returns The current picked point, or null if no point is picked.
+     *
+     * @remarks
+     * This method checks if the VertexPicker is enabled. If not, it returns the current picked point.
+     * If enabled, it performs raycasting to find the closest intersecting object.
+     * It then determines the closest vertex or point on the face, based on the configuration settings.
+     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
+     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
+     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
+     */
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
+import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { Component, Components } from "../../core";
 /**
@@ -2249,13 +2280,14 @@ export declare class MeasurementUtils extends Component {
     private getVolumeOfMesh;
     private getSignedVolumeOfTriangle;
 }
+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;
-    private _xmlParser;
+    static xmlParser: XMLParser;
     config: Required<BCFTopicsConfig>;
     readonly list: DataMap<string, Topic>;
     readonly onSetup: Event<unknown>;
@@ -2271,6 +2303,13 @@ export declare class BCFTopics extends Component implements Disposable, Configur
      */
     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.
@@ -2335,11 +2374,33 @@ export declare class BCFTopics extends Component implements Disposable, Configur
     private getMarkupLabels;
     private getMarkupViewpoints;
     private getMarkupRelatedTopics;
-    load(world: World, data: Uint8Array): Promise<{
+    /**
+     * 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[];
     }>;
 }
+/**
+ * A Set of unique numbers representing different types of IFC geometries.
+ */
+export declare const GeometryTypes: Set<number>;
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
+}
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
 /**
@@ -2429,10 +2490,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 * as FRAGS from "@thatopen/fragments";
 import * as WEBIFC from "web-ifc";
 export declare class SpatialIdsFinder {
@@ -2505,14 +2562,6 @@ export declare const IfcElements: {
 export declare const IfcCategoryMap: {
     [key: number]: string;
 };
-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";
 export declare class IfcPropertiesUtils {
     static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
@@ -2538,528 +2587,381 @@ 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>>>;
 }
-import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+import { Topic } from "..";
+import { Viewpoint } from "../../../core/Viewpoints";
+import { Components } from "../../../core/Components";
 /**
- * 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.
+ * Represents a comment in a BCF Topic.
  */
-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;
+export declare class Comment {
+    date: Date;
+    author: string;
+    guid: string;
+    viewpoint?: Viewpoint;
+    modifiedAuthor?: string;
+    modifiedDate?: Date;
+    topic?: Topic;
+    private _components;
+    private _comment;
     /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
+     * Sets the comment text and updates the modified date and author.
+     * The author will be the one defined in BCFTopics.config.author
+     * @param value - The new comment text.
      */
-    enabled: boolean;
+    set comment(value: string);
     /**
-     * A unique identifier for the world.
+     * Gets the comment text.
+     * @returns The comment text.
      */
-    uuid: string;
+    get comment(): string;
     /**
-     * An optional name for the world.
+     * Constructs a new BCF Topic Comment instance.
+     * @param components - The Components instance.
+     * @param text - The initial comment text.
      */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
+    constructor(components: Components, text: string);
     /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
+     * Serializes the Comment instance into a BCF compliant XML string.
+     *
+     * @returns A string representing the Comment in BCFv2 XML format.
      */
-    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;
+    serialize(): string;
+}
+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;
+    forRelated: InverseAttribute;
+}>;
+import { IfcFragmentSettings } from "../../IfcLoader/src";
+/**
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ */
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
     /**
-     * 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.
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
      */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
-    /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
+    propertiesSize: number;
 }
 import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
 import { Components } from "../../Components";
+import { AsyncEvent, Event, World } from "../../Types";
 /**
- * Configuration interface for the {@link SimpleScene}. Defines properties for directional and ambient lights.
- */
-export interface SimpleSceneConfig {
-    directionalLight: {
-        color: THREE.Color;
-        intensity: number;
-        position: THREE.Vector3;
-    };
-    ambientLight: {
-        color: THREE.Color;
-        intensity: number;
-    };
-}
-/**
- * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add objects hierarchically, and easily dispose them when you are finished with it.
+ * Settings to configure the CullerRenderer.
  */
-export declare class SimpleScene extends BaseScene implements Configurable<{}> {
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
+export interface CullerRendererSettings {
     /**
-     * The underlying Three.js scene object.
-     * It is used to define the 3D space containing objects, lights, and cameras.
+     * Interval in milliseconds at which the visibility check should be performed.
+     * Default value is 1000.
      */
-    three: THREE.Scene;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<SimpleScene>;
+    updateInterval?: number;
     /**
-     * Configuration interface for the {@link SimpleScene}.
-     * Defines properties for directional and ambient lights.
+     * Width of the render target used for visibility checks.
+     * Default value is 512.
      */
-    config: Required<SimpleSceneConfig>;
-    constructor(components: Components);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): void;
+    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;
 }
-import * as THREE from "three";
-import { BaseRenderer, Event } from "../../Types";
-import { Components } from "../../Components";
 /**
- * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
+ * A base renderer to determine visibility on screen.
  */
-export declare class SimpleRenderer extends BaseRenderer {
+export declare class CullerRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
-     * Default is 'true'.
+     * 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.
      */
-    enabled: boolean;
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
     /**
-     * The HTML container of the THREE.js canvas where the scene is rendered.
+     * Whether this renderer is active or not. If not, it won't render anything.
      */
-    container: HTMLElement;
+    enabled: boolean;
     /**
-     * The THREE.js WebGLRenderer instance.
+     * 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.
      */
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
+    needsUpdate: boolean;
     /**
-     * Constructor for the SimpleRenderer class.
-     *
-     * @param components - The components instance.
-     * @param container - The HTML container where the THREE.js canvas will be rendered.
-     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
      */
-    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
-    /** {@link Updateable.update} */
-    update(): void;
+    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 Resizeable.getSize}. */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize: (size?: THREE.Vector2) => void;
     /**
-     * Sets up and manages the event listeners for the renderer.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
-     *
-     * @throws Will throw an error if the renderer does not have an HTML container.
+     * 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.
      */
-    setupEvents(active: boolean): void;
-    private resizeEvent;
-    private setupRenderer;
-    private onContextLost;
-    private onContextBack;
+    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 CameraControls from "camera-controls";
-import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
 import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
 /**
- * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
  */
-export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<SimpleCamera>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<SimpleCamera>;
-    /**
-     * Event that is triggered when the aspect of the camera has been updated.
-     * This event is useful when you need to perform actions after the aspect of the camera has been changed.
-     */
-    readonly onAspectUpdated: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
-     * A three.js PerspectiveCamera or OrthographicCamera instance.
-     * This camera is used for rendering the scene.
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
      */
-    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    private _allControls;
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
     /**
-     * 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.
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
      */
-    get controls(): CameraControls;
+    threshold: number;
     /**
-     * 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.
+     * Map of color code to THREE.InstancedMesh.
+     * Used to keep track of color-coded meshes.
      */
-    get enabled(): boolean;
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /**
-     * 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.
+     * Flag to indicate if the renderer is currently processing.
+     * Used to prevent concurrent processing.
      */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
+    isProcessing: boolean;
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private _intervalID;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
     /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
+     * 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}
      */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
-}
-import { IfcFragmentSettings } from "../../IfcLoader/src";
-/**
- * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
- */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     /**
-     * Amount of properties to be streamed.
-     * Defaults to 100 properties.
+     * 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}
      */
-    propertiesSize: number;
+    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 { Topic } from "..";
-import { Viewpoint } from "../../../core/Viewpoints";
-import { Components } from "../../../core/Components";
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
 /**
- * Represents a comment in a BCF Topic.
+ * 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 Comment {
-    date: Date;
-    author: string;
-    guid: string;
-    viewpoint?: Viewpoint;
-    modifiedAuthor?: string;
-    modifiedDate?: Date;
-    topic?: Topic;
-    private _components;
-    private _comment;
-    /**
-     * Sets the comment text and updates the modified date and author.
-     * The author will be the one defined in BCFTopics.config.author
-     * @param value - The new comment text.
-     */
-    set comment(value: string);
+export declare class AsyncEvent<T> {
     /**
-     * Gets the comment text.
-     * @returns The comment text.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    get comment(): string;
+    add(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
     /**
-     * Constructs a new BCF Topic Comment instance.
-     * @param components - The Components instance.
-     * @param text - The initial comment text.
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
      */
-    constructor(components: Components, text: string);
-    serialize(): string;
+    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 { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
 /**
- * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
+ * 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 SimpleRaycaster implements Disposable {
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** The components instance to which this Raycaster belongs. */
-    components: Components;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The position of the mouse in the screen. */
-    readonly mouse: Mouse;
-    /**
-     * A reference to the Three.js Raycaster instance.
-     * This is used for raycasting operations.
-     */
-    readonly three: THREE.Raycaster;
-    /**
-     * A reference to the world instance to which this Raycaster belongs.
-     * This is used to access the camera and meshes.
-     */
-    world: World;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+export declare class Event<T> {
     /**
-     * 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}.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    add(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
     /**
-     * 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.
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
      */
-    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;
+    remove(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => void;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
 }
 import * as THREE from "three";
-import { Disposable, Event } from "../../Types";
+import CameraControls from "camera-controls";
+import { Event } from "./event";
 /**
- * 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.
+ * Whether this component has to be manually destroyed once you are done with it to prevent [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects). This also ensures that the DOM events created by that component will be cleaned up.
  */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
+export interface Disposable {
     /**
-     * The real position of the mouse of the Three.js canvas.
+     * Destroys the object from memory to prevent a
+     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
      */
-    get position(): THREE.Vector2;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private setupEvents;
-}
-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;
-    forRelated: InverseAttribute;
-}>;
-import { SimplePlane } from "../../Clipper";
-import { DataSet } from "../../Types";
-export interface ViewpointCamera {
-    direction: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    position: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    aspectRatio: number;
-}
-export interface ViewpointPerspectiveCamera extends ViewpointCamera {
-    fov: number;
-}
-export interface ViewpointOrthographicCamera extends ViewpointCamera {
-    viewToWorldScale: number;
-}
-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;
-    clippingPlanes: DataSet<SimplePlane>;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
-    readonly exceptionComponents: DataSet<string>;
-    readonly selectionComponents: DataSet<string>;
-    readonly componentColors: DataMap<string, string[]>;
-    spacesVisible: boolean;
-    spaceBoundariesVisible: boolean;
-    openingsVisible: boolean;
-    defaultVisibility: boolean;
-    private get _selectionModelIdMap();
-    private get _exceptionModelIdMap();
-    get selection(): FRAGS.FragmentIdMap;
-    get exception(): FRAGS.FragmentIdMap;
-    get projection(): CameraProjection;
-    get position(): THREE.Vector3;
-    get direction(): THREE.Vector3;
-    private _components;
-    readonly world: World;
-    private get _managerVersion();
-    get topics(): import("../../../openbim/BCFTopics").Topic[];
-    constructor(components: Components, world: World, _config?: {
-        data?: Partial<BCFViewpoint>;
-        setCamera?: boolean;
-    });
-    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): Promise<void>;
-    set(data: Partial<BCFViewpoint>): this;
-    go(transition?: boolean): Promise<void>;
-    updateCamera(): void;
-    colorize(): void;
-    resetColors(): void;
-    private createComponentTags;
-    serialize(version?: import("../../../openbim/BCFTopics").BCFVersion): Promise<string>;
+    dispose: () => void | Promise<void>;
+    /** Fired after the tool has been disposed.  */
+    readonly onDisposed: Event<any>;
 }
-import * as THREE from "three";
-import { Hideable, Event, World, Disposable } from "../../Types";
-import { Components } from "../../Components";
 /**
- * Configuration interface for the {@link SimpleGrid} class.
+ * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
  */
-export interface GridConfig {
+export interface Hideable {
     /**
-     * The color of the grid lines.
+     * Whether the geometric representation of this component is
+     * currently visible or not in the
+     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
      */
-    color: THREE.Color;
+    visible: boolean;
+}
+/**
+ * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
+ */
+export interface Resizeable {
     /**
-     * The size of the primary grid lines.
+     * Sets size of this component (e.g. the resolution of a
+     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+     * component.
      */
-    size1: number;
+    resize: (size?: THREE.Vector2) => void;
+    /** Event that fires when the component has been resized. */
+    onResize: Event<THREE.Vector2>;
     /**
-     * The size of the secondary grid lines.
+     * Gets the current size of this component (e.g. the resolution of a
+     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
+     * component.
      */
-    size2: number;
+    getSize: () => THREE.Vector2;
+}
+/** Whether this component should be updated each frame. */
+export interface Updateable {
+    /** Actions that should be executed after updating the component. */
+    onAfterUpdate: Event<any>;
+    /** Actions that should be executed before updating the component. */
+    onBeforeUpdate: Event<any>;
     /**
-     * The distance at which the grid lines start to fade away.
+     * Function used to update the state of this component each frame. For
+     * instance, a renderer component will make a render each frame.
      */
-    distance: number;
+    update(delta?: number): void;
+}
+/** Basic type to describe the progress of any kind of process. */
+export interface Progress {
+    /** The amount of things that have been done already. */
+    current: number;
+    /** The total amount of things to be done by the process. */
+    total: number;
 }
 /**
- * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
  */
-export declare class SimpleGrid implements Hideable, Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The world instance to which this Raycaster belongs. */
-    world: World;
-    /** The components instance to which this grid belongs. */
-    components: Components;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
+export interface Createable {
+    /** Creates a new instance of an element (e.g. a new Dimension). */
+    create: (data: any) => void;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Finish the creation process of the component, successfully creating an
+     * instance of whatever the component creates.
      */
-    get fade(): boolean;
+    endCreation?: (data: any) => void;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Cancels the creation process of the component, going back to the state
+     * before starting to create.
      */
-    set fade(active: boolean);
-    /** The Three.js mesh that contains the infinite grid. */
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World, config: GridConfig);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
+    cancelCreation?: (data: any) => void;
+    /** Deletes an existing instance of an element (e.g. a Dimension). */
+    delete: (data: any) => void;
 }
 /**
- * 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.
+ * Whether this component supports to be configured.
  */
-export declare class Event<T> {
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
+export interface Configurable<T extends Record<string, any>> {
+    /** Wether this components has been already configured. */
+    isSetup: boolean;
+    /** Use the provided configuration to setup the tool. */
+    setup: (config?: Partial<T>) => void | Promise<void>;
+    /** Fired after successfully calling {@link Configurable.setup()}  */
+    readonly onSetup: Event<any>;
+    /** Object holding the tool configuration. Is not meant to be edited directly, if you need
+     * to make changes to this object, use {@link Configurable.setup()} just after the tool is instantiated.
      */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
+    config: Required<T>;
+}
+/**
+ * Whether a camera uses the Camera Controls library.
+ */
+export interface CameraControllable {
     /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
+     * An instance of CameraControls that provides camera control functionalities.
+     * This instance is used to manipulate the camera.
      */
-    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;
+    controls: CameraControls;
 }
 import { Base } from "./base";
 /**
@@ -3074,34 +2976,6 @@ export declare abstract class Component extends Base {
      */
     abstract enabled: boolean;
 }
-/**
- * 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 { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
 import { Components } from "../../Components";
 /**
@@ -3121,574 +2995,842 @@ export declare abstract class Base {
     /** Whether is component is {@link Configurable}. */
     isConfigurable: () => this is Configurable<any>;
 }
+import { Base } from "./base";
+import { World } from "./world";
+import { Event } from "./event";
+import { Components } from "../../Components";
+/**
+ * One of the elements that make a world. It can be either a scene, a camera or a renderer.
+ */
+export declare abstract class BaseWorldItem extends Base {
+    readonly worlds: Map<string, World>;
+    /**
+     * Event that is triggered when a world is added or removed from the 'worlds' map.
+     * The event payload contains the world instance and the action ("added" or "removed").
+     */
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
+    }>;
+    /**
+     * The current world this item is associated with. It can be null if no world is currently active.
+     */
+    currentWorld: World | null;
+    protected constructor(components: Components);
+}
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { BaseWorldItem } from "./base-world-item";
+import { CameraControllable } from "./interfaces";
+/**
+ * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
+ */
+export declare abstract class BaseCamera extends BaseWorldItem {
+    /**
+     * Whether the camera is enabled or not.
+     */
+    abstract enabled: boolean;
+    /**
+     * The Three.js camera instance.
+     */
+    abstract three: THREE.Camera;
+    /**
+     * Optional CameraControls instance for controlling the camera.
+     * This property is only available if the camera is controllable.
+     */
+    abstract controls?: CameraControls;
+    /**
+     * Checks whether the instance is {@link CameraControllable}.
+     *
+     * @returns True if the instance is controllable, false otherwise.
+     */
+    hasCameraControls: () => this is CameraControllable;
+}
+import * as THREE from "three";
+import { Vector2 } from "three";
+import { Event } from "./event";
+import { BaseWorldItem } from "./base-world-item";
+import { Disposable, Resizeable, Updateable } from "./interfaces";
+/**
+ * Abstract class representing a renderer for a 3D world. All renderers should use this class as a base.
+ */
+export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
+    /**
+     * The three.js WebGLRenderer instance associated with this renderer.
+     *
+     * @abstract
+     * @type {THREE.WebGLRenderer}
+     */
+    abstract three: THREE.WebGLRenderer;
+    /** {@link Updateable.onBeforeUpdate} */
+    onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onAfterUpdate} */
+    onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<undefined>;
+    /** {@link Resizeable.onResize} */
+    readonly onResize: Event<THREE.Vector2>;
+    /**
+     * Event that fires when there has been a change to the list of clipping
+     * planes used by the active renderer.
+     */
+    readonly onClippingPlanesUpdated: Event<unknown>;
+    /** {@link Updateable.update} */
+    abstract update(delta?: number): void | Promise<void>;
+    /** {@link Disposable.dispose} */
+    abstract dispose(): void;
+    /** {@link Resizeable.getSize} */
+    abstract getSize(): Vector2;
+    /** {@link Resizeable.resize} */
+    abstract resize(size: Vector2 | undefined): void;
+    /**
+     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
+     */
+    clippingPlanes: THREE.Plane[];
+    /**
+     * Updates the clipping planes and triggers the 'onClippingPlanesUpdated' event.
+     *
+     * @remarks
+     * This method is typically called when there is a change to the list of clipping planes
+     * used by the active renderer.
+     */
+    updateClippingPlanes(): void;
+    /**
+     * Sets or removes a clipping plane from the renderer.
+     *
+     * @param active - A boolean indicating whether the clipping plane should be active or not.
+     * @param plane - The clipping plane to be added or removed.
+     * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to 'false'.
+     *
+     * @remarks
+     * This method adds or removes a clipping plane from the 'clippingPlanes' array.
+     * If 'active' is 'true' and the plane is not already in the array, it is added.
+     * If 'active' is 'false' and the plane is in the array, it is removed.
+     * The 'three.clippingPlanes' property is then updated to reflect the current state of the 'clippingPlanes' array,
+     * excluding any planes marked as local.
+     */
+    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
+}
+import * as THREE from "three";
+import { Disposable } from "./interfaces";
+import { Event } from "./event";
+import { Components } from "../../Components";
+import { BaseWorldItem } from "./base-world-item";
+/**
+ * Abstract class representing a base scene in the application. All scenes should use this class as a base.
+ */
+export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Abstract property representing the three.js object associated with this scene.
+     * It should be implemented by subclasses.
+     */
+    abstract three: THREE.Object3D;
+    /** The set of directional lights managed by this scene component. */
+    directionalLights: Map<string, THREE.DirectionalLight>;
+    /** The set of ambient lights managed by this scene component. */
+    ambientLights: Map<string, THREE.AmbientLight>;
+    protected constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+}
 import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Event } from "./event";
+import { BaseScene } from "./base-scene";
+import { BaseCamera } from "./base-camera";
+import { BaseRenderer } from "./base-renderer";
+import { Updateable, Disposable } from "./interfaces";
 /**
- * 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.
+ * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
  */
-export interface Disposable {
+export interface World extends Disposable, Updateable {
     /**
-     * Destroys the object from memory to prevent a
-     * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+     * A set of meshes present in the world. This is taken into account for operations like raycasting.
      */
-    dispose: () => void | Promise<void>;
-    /** Fired after the tool has been disposed.  */
-    readonly onDisposed: Event<any>;
-}
-/**
- * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
- */
-export interface Hideable {
+    meshes: Set<THREE.Mesh>;
     /**
-     * Whether the geometric representation of this component is
-     * currently visible or not in the
-     * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
+     * The base scene of the world.
      */
-    visible: boolean;
-}
-/**
- * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
- */
-export interface Resizeable {
+    scene: BaseScene;
     /**
-     * Sets size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
+     * The base camera of the world.
      */
-    resize: (size?: THREE.Vector2) => void;
-    /** Event that fires when the component has been resized. */
-    onResize: Event<THREE.Vector2>;
+    camera: BaseCamera;
     /**
-     * Gets the current size of this component (e.g. the resolution of a
-     * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
-     * component.
+     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
      */
-    getSize: () => THREE.Vector2;
-}
-/** Whether this component should be updated each frame. */
-export interface Updateable {
-    /** Actions that should be executed after updating the component. */
-    onAfterUpdate: Event<any>;
-    /** Actions that should be executed before updating the component. */
-    onBeforeUpdate: Event<any>;
+    renderer: BaseRenderer | null;
     /**
-     * Function used to update the state of this component each frame. For
-     * instance, a renderer component will make a render each frame.
+     * A unique identifier for the world.
      */
-    update(delta?: number): void;
-}
-/** Basic type to describe the progress of any kind of process. */
-export interface Progress {
-    /** The amount of things that have been done already. */
-    current: number;
-    /** The total amount of things to be done by the process. */
-    total: number;
+    uuid: string;
+    /**
+     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     */
+    isDisposing: boolean;
 }
+import { Event } from "./event";
 /**
- * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
+ * A class that extends the built-in Set class and provides additional functionality.
+ * It triggers events when items are added, deleted, or the set is cleared.
+ *
+ * @template T - The type of elements in the set.
  */
-export interface Createable {
-    /** Creates a new instance of an element (e.g. a new Dimension). */
-    create: (data: any) => void;
+export declare class DataSet<T> extends Set<T> {
     /**
-     * Finish the creation process of the component, successfully creating an
-     * instance of whatever the component creates.
+     * An event that is triggered when a new item is added to the set.
      */
-    endCreation?: (data: any) => void;
+    readonly onItemAdded: Event<T>;
     /**
-     * Cancels the creation process of the component, going back to the state
-     * before starting to create.
+     * An event that is triggered when an item is deleted from the set.
      */
-    cancelCreation?: (data: any) => void;
-    /** Deletes an existing instance of an element (e.g. a Dimension). */
-    delete: (data: any) => void;
-}
-/**
- * Whether this component supports to be configured.
- */
-export interface Configurable<T extends Record<string, any>> {
-    /** Wether this components has been already configured. */
-    isSetup: boolean;
-    /** Use the provided configuration to setup the tool. */
-    setup: (config?: Partial<T>) => void | Promise<void>;
-    /** Fired after successfully calling {@link Configurable.setup()}  */
-    readonly onSetup: Event<any>;
-    /** Object holding the tool configuration. Is not meant to be edited directly, if you need
-     * to make changes to this object, use {@link Configurable.setup()} just after the tool is instantiated.
+    readonly onItemDeleted: Event<unknown>;
+    /**
+     * An event that is triggered when the set is cleared.
      */
-    config: Required<T>;
-}
-/**
- * Whether a camera uses the Camera Controls library.
- */
-export interface CameraControllable {
+    readonly onCleared: Event<unknown>;
     /**
-     * An instance of CameraControls that provides camera control functionalities.
-     * This instance is used to manipulate the camera.
+     * Constructs a new instance of the DataSet class.
+     *
+     * @param iterable - An optional iterable object to initialize the set with.
      */
-    controls: CameraControls;
+    constructor(iterable?: Iterable<T> | null);
+    /**
+     * Clears the set and triggers the onCleared event.
+     */
+    clear(): void;
+    /**
+     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
+     *
+     * @param value - The value to add to the set.
+     * @returns - The set instance.
+     */
+    add(...value: T[]): this;
+    /**
+     * A function that acts as a guard for adding items to the set.
+     * It determines whether a given value should be allowed to be added to the set.
+     *
+     * @param value - The value to be checked against the guard.
+     * @returns A boolean indicating whether the value should be allowed to be added to the set.
+     *          By default, this function always returns true, allowing all values to be added.
+     *          You can override this behavior by providing a custom implementation.
+     */
+    guard: (value: T) => boolean;
+    /**
+     * Deletes a value from the set and triggers the onItemDeleted event.
+     *
+     * @param value - The value to delete from the set.
+     * @returns - True if the value was successfully deleted, false otherwise.
+     */
+    delete(value: T): boolean;
+    /**
+     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
+     */
+    dispose(): void;
 }
-import { Base } from "./base";
-import { World } from "./world";
 import { Event } from "./event";
-import { Components } from "../../Components";
 /**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
+ * A class that extends the built-in Map class and provides additional events for item set, update, delete, and clear operations.
+ *
+ * @template K - The type of keys in the map.
+ * @template V - The type of values in the map.
  */
-export declare abstract class BaseWorldItem extends Base {
-    readonly worlds: Map<string, World>;
+export declare class DataMap<K, V> extends Map<K, V> {
     /**
-     * Event that is triggered when a world is added or removed from the 'worlds' map.
-     * The event payload contains the world instance and the action ("added" or "removed").
+     * An event triggered when a new item is set in the map.
      */
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
+    readonly onItemSet: Event<{
+        key: K;
+        value: V;
     }>;
     /**
-     * The current world this item is associated with. It can be null if no world is currently active.
+     * An event triggered when an existing item in the map is updated.
      */
-    currentWorld: World | null;
-    protected constructor(components: Components);
+    readonly onItemUpdated: Event<{
+        key: K;
+        value: V;
+    }>;
+    /**
+     * An event triggered when an item is deleted from the map.
+     */
+    readonly onItemDeleted: Event<K>;
+    /**
+     * An event triggered when the map is cleared.
+     */
+    readonly onCleared: Event<unknown>;
+    /**
+     * Constructs a new DataMap instance.
+     *
+     * @param iterable - An iterable object containing key-value pairs to populate the map.
+     */
+    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
+    /**
+     * Clears the map and triggers the onCleared event.
+     */
+    clear(): void;
+    /**
+     * Sets the value for the specified key in the map and triggers the appropriate event (onItemSet or onItemUpdated).
+     *
+     * @param key - The key of the item to set.
+     * @param value - The value of the item to set.
+     * @returns The DataMap instance.
+     */
+    set(key: K, value: V): this;
+    /**
+     * A function that acts as a guard for adding items to the set.
+     * It determines whether a given value should be allowed to be added to the set.
+     *
+     * @param key - The key of the entry to be checked against the guard.
+     * @param value - The value of the entry to be checked against the guard.
+     * @returns A boolean indicating whether the value should be allowed to be added to the set.
+     *          By default, this function always returns true, allowing all values to be added.
+     *          You can override this behavior by providing a custom implementation.
+     */
+    guard: (key: K, value: V) => boolean;
+    /**
+     * Deletes the specified key from the map and triggers the onItemDeleted event if the key was found.
+     *
+     * @param key - The key of the item to delete.
+     * @returns True if the key was found and deleted; otherwise, false.
+     */
+    delete(key: K): boolean;
+    /**
+     * Clears the map and resets the events.
+     */
+    dispose(): void;
+}
+import * as THREE from "three";
+import { Disposable, Event } from "../../Types";
+/**
+ * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
+ */
+export declare class Mouse implements Disposable {
+    dom: HTMLCanvasElement;
+    private _event?;
+    private _position;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    constructor(dom: HTMLCanvasElement);
+    /**
+     * The real position of the mouse of the Three.js canvas.
+     */
+    get position(): THREE.Vector2;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private getPositionY;
+    private getPositionX;
+    private updateMouseInfo;
+    private setupEvents;
 }
 import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { BaseWorldItem } from "./base-world-item";
-import { CameraControllable } from "./interfaces";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+import { Mouse } from "./mouse";
 /**
- * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
+ * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
  */
-export declare abstract class BaseCamera extends BaseWorldItem {
+export declare class SimpleRaycaster implements Disposable {
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /** The components instance to which this Raycaster belongs. */
+    components: Components;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** The position of the mouse in the screen. */
+    readonly mouse: Mouse;
     /**
-     * Whether the camera is enabled or not.
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
      */
-    abstract enabled: boolean;
+    readonly three: THREE.Raycaster;
     /**
-     * The Three.js camera instance.
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
      */
-    abstract three: THREE.Camera;
+    world: World;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
+     * 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}.
      */
-    abstract controls?: CameraControls;
+    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
     /**
-     * Checks whether the instance is {@link CameraControllable}.
+     * 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.
      *
-     * @returns True if the instance is controllable, false otherwise.
+     * @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.
      */
-    hasCameraControls: () => this is CameraControllable;
+    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 { 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 { Vector2 } from "three";
-import { Event } from "./event";
-import { BaseWorldItem } from "./base-world-item";
-import { Disposable, Resizeable, Updateable } from "./interfaces";
-/**
- * Abstract class representing a renderer for a 3D world. All renderers should use this class as a base.
- */
-export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
+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;
     /**
-     * The three.js WebGLRenderer instance associated with this renderer.
-     *
-     * @abstract
-     * @type {THREE.WebGLRenderer}
+     * 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.
      */
-    abstract three: THREE.WebGLRenderer;
-    /** {@link Updateable.onBeforeUpdate} */
-    onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<undefined>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
+    clippingPlanes: DataSet<SimplePlane>;
+    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
     /**
-     * Event that fires when there has been a change to the list of clipping
-     * planes used by the active renderer.
+     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
      */
-    readonly onClippingPlanesUpdated: Event<unknown>;
-    /** {@link Updateable.update} */
-    abstract update(delta?: number): void | Promise<void>;
-    /** {@link Disposable.dispose} */
-    abstract dispose(): void;
-    /** {@link Resizeable.getSize} */
-    abstract getSize(): Vector2;
-    /** {@link Resizeable.resize} */
-    abstract resize(size: Vector2 | undefined): void;
+    readonly exceptionComponents: DataSet<string>;
     /**
-     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
+     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
      */
-    clippingPlanes: THREE.Plane[];
+    readonly selectionComponents: DataSet<string>;
     /**
-     * Updates the clipping planes and triggers the 'onClippingPlanesUpdated' event.
-     *
-     * @remarks
-     * This method is typically called when there is a change to the list of clipping planes
-     * used by the active renderer.
+     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
+     * For this to work, call viewpoint.colorize()
      */
-    updateClippingPlanes(): void;
+    readonly componentColors: DataMap<string, string[]>;
     /**
-     * Sets or removes a clipping plane from the renderer.
-     *
-     * @param active - A boolean indicating whether the clipping plane should be active or not.
-     * @param plane - The clipping plane to be added or removed.
-     * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to 'false'.
-     *
-     * @remarks
-     * This method adds or removes a clipping plane from the 'clippingPlanes' array.
-     * If 'active' is 'true' and the plane is not already in the array, it is added.
-     * If 'active' is 'false' and the plane is in the array, it is removed.
-     * The 'three.clippingPlanes' property is then updated to reflect the current state of the 'clippingPlanes' array,
-     * excluding any planes marked as local.
+     * 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
      */
-    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
-}
-import * as THREE from "three";
-import { Disposable } from "./interfaces";
-import { Event } from "./event";
-import { Components } from "../../Components";
-import { BaseWorldItem } from "./base-world-item";
-/**
- * Abstract class representing a base scene in the application. All scenes should use this class as a base.
- */
-export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    spacesVisible: boolean;
     /**
-     * Abstract property representing the three.js object associated with this scene.
-     * It should be implemented by subclasses.
+     * Boolean flags to allow fine control over the visibility of space boundaries.
+     * A typical use of these flags is when DefaultVisibility=true but space boundaries should remain hidden.
+     * @default false
      */
-    abstract three: THREE.Object3D;
-    /** The set of directional lights managed by this scene component. */
-    directionalLights: Map<string, THREE.DirectionalLight>;
-    /** The set of ambient lights managed by this scene component. */
-    ambientLights: Map<string, THREE.AmbientLight>;
-    protected constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}
-import * as THREE from "three";
-import { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
-/**
- * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
- */
-export interface World extends Disposable, Updateable {
+    spaceBoundariesVisible: boolean;
     /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
+     * 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
      */
-    meshes: Set<THREE.Mesh>;
+    openingsVisible: boolean;
     /**
-     * The base scene of the world.
+     * When true, all components should be visible unless listed in the exceptions
+     * When false all components should be invisible unless listed in the exceptions
      */
-    scene: BaseScene;
+    defaultVisibility: boolean;
+    private get _selectionModelIdMap();
+    private get _exceptionModelIdMap();
     /**
-     * The base camera of the world.
+     * A list of components that should be selected (highlighted) when displaying a viewpoint.
+     * @returns The fragmentIdMap for components marked as selections.
      */
-    camera: BaseCamera;
+    get selection(): FRAGS.FragmentIdMap;
     /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
+     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
+     * @returns The fragmentIdMap for components marked as exceptions.
      */
-    renderer: BaseRenderer | null;
+    get exception(): FRAGS.FragmentIdMap;
     /**
-     * A unique identifier for the world.
+     * 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'.
      */
-    uuid: string;
+    get projection(): CameraProjection;
     /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     * 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.
      */
-    isDisposing: boolean;
-}
-import { Event } from "./event";
-/**
- * A class that extends the built-in Set class and provides additional functionality.
- * It triggers events when items are added, deleted, or the set is cleared.
- *
- * @template T - The type of elements in the set.
- */
-export declare class DataSet<T> extends Set<T> {
+    get position(): THREE.Vector3;
     /**
-     * An event that is triggered when a new item is added to the set.
+     * 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.
      */
-    readonly onItemAdded: Event<T>;
+    get direction(): THREE.Vector3;
+    private _components;
     /**
-     * An event that is triggered when an item is deleted from the set.
+     * Represents the world in which the viewpoints are created and managed.
      */
-    readonly onItemDeleted: Event<unknown>;
+    readonly world: World;
+    private get _managerVersion();
     /**
-     * An event that is triggered when the set is cleared.
+     * 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.
      */
-    readonly onCleared: Event<unknown>;
+    get topics(): import("../../../openbim/BCFTopics").Topic[];
+    constructor(components: Components, world: World, _config?: {
+        data?: Partial<BCFViewpoint>;
+        setCamera?: boolean;
+    });
     /**
-     * Constructs a new instance of the DataSet class.
+     * Adds components to the viewpoint based on the provided fragment ID map.
      *
-     * @param iterable - An optional iterable object to initialize the set with.
+     * @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.
      */
-    constructor(iterable?: Iterable<T> | null);
+    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): Promise<void>;
     /**
-     * Clears the set and triggers the onCleared event.
+     * 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.
      */
-    clear(): void;
+    set(data: Partial<BCFViewpoint>): this;
     /**
-     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
+     * Sets the viewpoint of the camera in the world.
      *
-     * @param value - The value to add to the set.
-     * @returns - The set instance.
+     * @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.
      */
-    add(...value: T[]): this;
+    go(transition?: boolean): Promise<void>;
     /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
+     * Updates the camera settings of the viewpoint based on the current world's camera and renderer.
      *
-     * @param value - The value to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
+     * @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.
      */
-    guard: (value: T) => boolean;
+    updateCamera(): void;
     /**
-     * Deletes a value from the set and triggers the onItemDeleted event.
+     * Applies color to the components in the viewpoint based on their GUIDs.
      *
-     * @param value - The value to delete from the set.
-     * @returns - True if the value was successfully deleted, false otherwise.
+     * 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 '#'.
      */
-    delete(value: T): boolean;
+    colorize(): void;
     /**
-     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
+     * 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.
      */
-    dispose(): void;
+    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>;
 }
-import { Event } from "./event";
+import * as THREE from "three";
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
 /**
- * A class that extends the built-in Map class and provides additional events for item set, update, delete, and clear operations.
+ * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
  *
- * @template K - The type of keys in the map.
- * @template V - The type of values in the map.
+ * @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 DataMap<K, V> extends Map<K, V> {
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
     /**
-     * An event triggered when a new item is set in the map.
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
      */
-    readonly onItemSet: Event<{
-        key: K;
-        value: V;
-    }>;
+    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>;
     /**
-     * An event triggered when an existing item in the map is updated.
+     * 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.
      */
-    readonly onItemUpdated: Event<{
-        key: K;
-        value: V;
-    }>;
+    isDisposing: boolean;
     /**
-     * An event triggered when an item is deleted from the map.
+     * Indicates whether the world is currently enabled.
+     * When disabled, the world will not be updated.
      */
-    readonly onItemDeleted: Event<K>;
+    enabled: boolean;
     /**
-     * An event triggered when the map is cleared.
+     * A unique identifier for the world.
      */
-    readonly onCleared: Event<unknown>;
+    uuid: string;
     /**
-     * Constructs a new DataMap instance.
-     *
-     * @param iterable - An iterable object containing key-value pairs to populate the map.
+     * An optional name for the world.
      */
-    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
+    name?: string;
+    private _scene?;
+    private _camera?;
+    private _renderer;
     /**
-     * Clears the map and triggers the onCleared event.
+     * Getter for the scene. If no scene is initialized, it throws an error.
+     * @returns The current scene.
      */
-    clear(): void;
+    get scene(): T;
     /**
-     * Sets the value for the specified key in the map and triggers the appropriate event (onItemSet or onItemUpdated).
-     *
-     * @param key - The key of the item to set.
-     * @param value - The value of the item to set.
-     * @returns The DataMap instance.
+     * 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(key: K, value: V): this;
+    set scene(scene: T);
     /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
-     *
-     * @param key - The key of the entry to be checked against the guard.
-     * @param value - The value of the entry to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
+     * Getter for the camera. If no camera is initialized, it throws an error.
+     * @returns The current camera.
      */
-    guard: (key: K, value: V) => boolean;
+    get camera(): U;
     /**
-     * Deletes the specified key from the map and triggers the onItemDeleted event if the key was found.
-     *
-     * @param key - The key of the item to delete.
-     * @returns True if the key was found and deleted; otherwise, false.
+     * 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.
      */
-    delete(key: K): boolean;
+    set camera(camera: U);
     /**
-     * Clears the map and resets the events.
+     * 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).
      */
-    dispose(): void;
+    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 { BaseScene, Configurable, Event } from "../../Types";
 import { Components } from "../../Components";
-import { AsyncEvent, Event, World } from "../../Types";
 /**
- * Settings to configure the CullerRenderer.
+ * Configuration interface for the {@link SimpleScene}. Defines properties for directional and ambient lights.
  */
-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;
+export interface SimpleSceneConfig {
+    directionalLight: {
+        color: THREE.Color;
+        intensity: number;
+        position: THREE.Vector3;
+    };
+    ambientLight: {
+        color: THREE.Color;
+        intensity: number;
+    };
+}
+/**
+ * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add objects hierarchically, and easily dispose them when you are finished with it.
+ */
+export declare class SimpleScene extends BaseScene implements Configurable<{}> {
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
     /**
-     * Height of the render target used for visibility checks.
-     * Default value is 512.
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
      */
-    height?: number;
+    three: THREE.Scene;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<SimpleScene>;
     /**
-     * Whether the visibility check should be performed automatically.
-     * Default value is true.
+     * Configuration interface for the {@link SimpleScene}.
+     * Defines properties for directional and ambient lights.
      */
-    autoUpdate?: boolean;
+    config: Required<SimpleSceneConfig>;
+    constructor(components: Components);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleSceneConfig>): void;
 }
+import * as THREE from "three";
+import { BaseRenderer, Event } from "../../Types";
+import { Components } from "../../Components";
 /**
- * A base renderer to determine visibility on screen.
+ * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
  */
-export declare class CullerRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+export declare class SimpleRenderer extends BaseRenderer {
     /**
-     * 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.
+     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
+     * Default is 'true'.
      */
-    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
+    enabled: boolean;
     /**
-     * Whether this renderer is active or not. If not, it won't render anything.
+     * The HTML container of the THREE.js canvas where the scene is rendered.
      */
-    enabled: boolean;
+    container: HTMLElement;
     /**
-     * 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.
+     * The THREE.js WebGLRenderer instance.
      */
-    needsUpdate: boolean;
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<unknown>;
+    private _resizing;
     /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
+     * Constructor for the SimpleRenderer class.
+     *
+     * @param components - The components instance.
+     * @param container - The HTML container where the THREE.js canvas will be rendered.
+     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
      */
-    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);
+    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
+    /** {@link Updateable.update} */
+    update(): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /** {@link Resizeable.getSize}. */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize: (size?: THREE.Vector2) => void;
     /**
-     * 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.
+     * Sets up and manages the event listeners for the renderer.
+     *
+     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
+     *
+     * @throws Will throw an error if the renderer does not have an HTML container.
      */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-    private applySettings;
+    setupEvents(active: boolean): void;
+    private resizeEvent;
+    private setupRenderer;
+    private onContextLost;
+    private onContextBack;
 }
 import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
+import CameraControls from "camera-controls";
+import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
 import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
 /**
- * A renderer to hide/show meshes depending on their visibility from the user's point of view.
+ * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
  */
-export 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>;
-    }>;
+export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<SimpleCamera>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<SimpleCamera>;
     /**
-     * Pixels in screen a geometry must occupy to be considered "seen".
-     * Default value is 100.
+     * Event that is triggered when the aspect of the camera has been updated.
+     * This event is useful when you need to perform actions after the aspect of the camera has been changed.
      */
-    threshold: number;
+    readonly onAspectUpdated: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
+     * A three.js PerspectiveCamera or OrthographicCamera instance.
+     * This camera is used for rendering the scene.
      */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    private _allControls;
     /**
-     * Flag to indicate if the renderer is currently processing.
-     * Used to prevent concurrent processing.
+     * 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.
      */
-    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;
+    get controls(): CameraControls;
     /**
-     * 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}
+     * 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.
      */
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    get enabled(): boolean;
     /**
-     * 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}
+     * 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.
      */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    set enabled(enabled: boolean);
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(_delta: number): 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}
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
      */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
 }
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
@@ -3705,73 +3847,6 @@ export declare class FirstPersonMode implements NavigationMode {
     set(active: boolean): void;
     private setupFirstPersonCamera;
 }
-import * as THREE from "three";
-import { Event, World } from "../../Types";
-import { Components } from "../../Components";
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class DistanceRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
-     */
-    readonly onDistanceComputed: Event<number>;
-    /**
-     * Objects that won't be taken into account in the distance check.
-     */
-    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
-    /**
-     * Whether this renderer is active or not. If not, it won't render anything.
-     */
-    enabled: boolean;
-    /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
-     */
-    renderDebugFrame: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /**
-     * The scene where the distance is computed.
-     */
-    scene: THREE.Scene;
-    /**
-     * The camera used to compute the distance.
-     */
-    camera: THREE.OrthographicCamera;
-    /**
-     * The material used to compute the distance.
-     */
-    depthMaterial: THREE.ShaderMaterial;
-    /** The world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected readonly worker: Worker;
-    private _width;
-    private _height;
-    private readonly _postQuad;
-    private readonly tempRT;
-    private readonly resultRT;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
-     */
-    compute: () => Promise<void>;
-    private handleWorkerMessage;
-}
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
@@ -3868,16 +3943,91 @@ 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;
+     * 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 { Hideable, Event, World, Disposable } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * Configuration interface for the {@link SimpleGrid} class.
+ */
+export interface GridConfig {
+    /**
+     * The color of the grid lines.
+     */
+    color: THREE.Color;
+    /**
+     * The size of the primary grid lines.
+     */
+    size1: number;
+    /**
+     * The size of the secondary grid lines.
+     */
+    size2: number;
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
+    distance: number;
+}
+/**
+ * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ */
+export declare class SimpleGrid implements Hideable, Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** The world instance to which this Raycaster belongs. */
+    world: World;
+    /** The components instance to which this grid belongs. */
+    components: Components;
+    /** {@link Hideable.visible} */
+    get visible(): boolean;
+    /** {@link Hideable.visible} */
+    set visible(visible: boolean);
+    /** The material of the grid. */
+    get material(): THREE.ShaderMaterial;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    get fade(): boolean;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    set fade(active: boolean);
+    /** The Three.js mesh that contains the infinite grid. */
+    readonly three: THREE.Mesh;
+    private _fade;
+    constructor(components: Components, world: World, config: GridConfig);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private setupEvents;
+    private updateZoom;
+}
+import { IfcFragmentSettings } from "../../IfcLoader/src";
+/**
+ * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
+ */
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
+    /**
+     * Minimum number of geometries to be streamed.
+     * Defaults to 10 geometries.
+     */
+    minGeometrySize: number;
+    /**
+     * Minimum amount of assets to be streamed.
+     * Defaults to 1000 assets.
+     */
+    minAssetsSize: number;
 }
 import * as THREE from "three";
 import * as WEBIFC from "web-ifc";
@@ -3894,10 +4044,34 @@ export declare class CivilReader {
     } | undefined;
     private getCurves;
 }
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+/**
+ * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
+ */
+export interface StreamedGeometries {
+    [id: number]: {
+        /** The bounding box of the geometry as a Float32Array. */
+        boundingBox: Float32Array;
+        /** A boolean indicating whether the geometry has holes. */
+        hasHoles: boolean;
+        /** An optional file path for the geometry data. */
+        geometryFile?: string;
+    };
+}
+/**
+ * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
+ */
+export interface StreamedAsset {
+    /** The unique identifier of the asset. */
+    id: number;
+    /** An array of geometries associated with the asset. */
+    geometries: {
+        /** The unique identifier of the geometry. */
+        geometryID: number;
+        /** The transformation matrix of the geometry as a number array. */
+        transformation: number[];
+        /** The color of the geometry as a number array. */
+        color: number[];
+    }[];
 }
 import * as WEBIFC from "web-ifc";
 import * as THREE from "three";
@@ -3909,6 +4083,11 @@ export declare class Units {
     private getLengthUnits;
     private getScaleMatrix;
 }
+import * as WEBIFC from "web-ifc";
+export declare class IfcMetadataReader {
+    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+}
 import * as THREE from "three";
 import { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
@@ -4008,50 +4187,72 @@ export declare class SimplePlane implements Disposable, Hideable {
     private newHelper;
     private static newPlaneMesh;
 }
+import * as THREE from "three";
+import { Event, World } from "../../Types";
+import { Components } from "../../Components";
 /**
- * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
- */
-export interface StreamedGeometries {
-    [id: number]: {
-        /** The bounding box of the geometry as a Float32Array. */
-        boundingBox: Float32Array;
-        /** A boolean indicating whether the geometry has holes. */
-        hasHoles: boolean;
-        /** An optional file path for the geometry data. */
-        geometryFile?: string;
-    };
-}
-/**
- * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
- */
-export interface StreamedAsset {
-    /** The unique identifier of the asset. */
-    id: number;
-    /** An array of geometries associated with the asset. */
-    geometries: {
-        /** The unique identifier of the geometry. */
-        geometryID: number;
-        /** The transformation matrix of the geometry as a number array. */
-        transformation: number[];
-        /** The color of the geometry as a number array. */
-        color: number[];
-    }[];
-}
-import { IfcFragmentSettings } from "../../IfcLoader/src";
-/**
- * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
+ * A base renderer to determine visibility on screen.
  */
-export declare class IfcStreamingSettings extends IfcFragmentSettings {
+export declare class DistanceRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Minimum number of geometries to be streamed.
-     * Defaults to 10 geometries.
+     * 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.
      */
-    minGeometrySize: number;
+    readonly onDistanceComputed: Event<number>;
     /**
-     * Minimum amount of assets to be streamed.
-     * Defaults to 1000 assets.
+     * Objects that won't be taken into account in the distance check.
      */
-    minAssetsSize: number;
+    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
+    /**
+     * Whether this renderer is active or not. If not, it won't render anything.
+     */
+    enabled: boolean;
+    /**
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
+     */
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /**
+     * The scene where the distance is computed.
+     */
+    scene: THREE.Scene;
+    /**
+     * The camera used to compute the distance.
+     */
+    camera: THREE.OrthographicCamera;
+    /**
+     * The material used to compute the distance.
+     */
+    depthMaterial: THREE.ShaderMaterial;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected readonly worker: Worker;
+    private _width;
+    private _height;
+    private readonly _postQuad;
+    private readonly tempRT;
+    private readonly resultRT;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    compute: () => Promise<void>;
+    private handleWorkerMessage;
 }
 import { Components } from "../../../core/Components";
 import { Viewpoint } from "../../../core/Viewpoints";
@@ -4068,12 +4269,6 @@ export declare class Topic implements BCFTopic {
      *
      * @remarks
      * The 'guid' is automatically generated upon topic creation and by no means it should change.
-     *
-     * @example
-     * '''typescript
-     * const topic = new Topic(components);
-     * console.log(topic.guid); // Output: "123e4567-e89b-12d3-a456-426614174000"
-     * '''
      */
     guid: string;
     title: string;
@@ -4201,112 +4396,80 @@ export interface BCFTopic {
     description?: string;
     stage?: string;
 }
+/**
+ * Configuration settings for managing BCF topics.
+ * This interface defines the properties and their meanings used to control the behavior of exporting and importing BCF topics.
+ */
 export interface BCFTopicsConfig {
+    /**
+     * The BCF version used during export.
+     */
     version: BCFVersion;
+    /**
+     * The email of the user creating topics using this component.
+     */
     author: string;
+    /**
+     * The set of allowed topic types. This is exported inside the
+     * [bcf.extensions](https://github.com/buildingSMART/BCF-XML/tree/release_3_0/Documentation#bcf-file-structure).
+     */
     types: Set<string>;
+    /**
+     * The set of allowed topic statuses. This is exported inside the
+     * [bcf.extensions](https://github.com/buildingSMART/BCF-XML/tree/release_3_0/Documentation#bcf-file-structure).
+     */
     statuses: Set<string>;
+    /**
+     * The set of allowed topic priorities. This is exported inside the
+     * [bcf.extensions](https://github.com/buildingSMART/BCF-XML/tree/release_3_0/Documentation#bcf-file-structure).
+     */
     priorities: Set<string>;
+    /**
+     * The set of allowed topic labels. This is exported inside the
+     * [bcf.extensions](https://github.com/buildingSMART/BCF-XML/tree/release_3_0/Documentation#bcf-file-structure).
+     */
     labels: Set<string>;
+    /**
+     * The set of allowed topic stages. This is exported inside the
+     * [bcf.extensions](https://github.com/buildingSMART/BCF-XML/tree/release_3_0/Documentation#bcf-file-structure).
+     */
     stages: Set<string>;
+    /**
+     * The set of allowed topic users. This is exported inside the
+     * [bcf.extensions](https://github.com/buildingSMART/BCF-XML/tree/release_3_0/Documentation#bcf-file-structure).
+     */
     users: Set<string>;
+    /**
+     * Whether or not to include the AuthoringSoftwareId in the viewpoint components during export.
+     */
     includeSelectionTag: boolean;
+    /**
+     * Updates the types, statuses, users, etc., after importing an external BCF.
+     */
     updateExtensionsOnImport: boolean;
+    /**
+     * Only allow to use the extensions (types, statuses, etc.) defined in the config when setting the corresponding data in a topic.
+     */
     strict: boolean;
+    /**
+     * If true, export the extensions (types, status, etc.) based on topics data. This doesn't update the extensions in the config.
+     * If false, only export the extensions defined in each collection of possibilities set in the config.
+     * In all cases, all the values from each collection of extensions defined in the config are going to be exported.
+     */
     includeAllExtensionsOnExport: boolean;
+    /**
+     * Version to be used when importing if no bcf.version file is present in the incoming data.
+     * When null, the importer will throw an error if the version is missing or is not supported.
+     */
     fallbackVersionOnImport: BCFVersion | null;
+    /**
+     * If true, do not import a topic with missing information (guid, type, status, title, creationDate or creationAuthor).
+     * If false, use default values for missing data.
+     */
     ignoreIncompleteTopicsOnImport: boolean;
 }
-import * as BUI from "@thatopen/ui";
-import { TopicFormUI } from "./src/template";
-/**
- * Creates a Topic Form component with the given UI state.
- *
- * @param state - The initial state of the Topic Form component.
- *
- * @returns A tuple containing the created Topic Form component and a function to update it.
- */
-export declare const topicForm: (state: TopicFormUI) => [element: BUI.Table, update: (state?: Partial<TopicFormUI> | undefined) => TopicFormUI, currentState: () => TopicFormUI];
-import * as BUI from "@thatopen/ui";
-import { TopicPanelUI } from "./src/template";
-/**
- * Creates a Topic Panel component with the given UI state.
- *
- * @param state - The initial state of the Topic Panel component.
- * @param autoUpdate - A flag indicating whether the component should automatically update based on events happening in the BCFTopic component.
- * Default value is 'true'.
- *
- * @returns A tuple containing the created Topic Panel component and a function to update it.
- */
-export declare const topicPanel: (state: TopicPanelUI, autoUpdate?: boolean) => [element: BUI.Table, update: (state?: Partial<TopicPanelUI> | undefined) => TopicPanelUI, currentState: () => TopicPanelUI];
-import * as BUI from "@thatopen/ui";
-import { BCFTopicsUI } from "./src/template";
-/**
- * Creates a BCF Topics List component with the given UI state.
- *
- * @param state - The initial state of the BCF Topics List component.
- * @param autoUpdate - A flag indicating whether the component should automatically update based on events happening in the BCFTopic component.
- * Default value is 'true'.
- *
- * @returns A tuple containing the created BCF Topics List component and a function to update it.
- */
-export declare const bcfTopicsList: (state: BCFTopicsUI, autoUpdate?: boolean) => [element: BUI.Table, update: (state?: Partial<BCFTopicsUI> | undefined) => BCFTopicsUI, currentState: () => BCFTopicsUI];
-import * as BUI from "@thatopen/ui";
-import { ViewpointsUI } from "./src/template";
-/**
- * Creates a Viewpoints component with the given UI state.
- *
- * @param state - The initial state of the Viewpoints component.
- * @param autoUpdate - A flag indicating whether the component should automatically update based on events happening in the BCFTopic component.
- * Default value is 'true'.
- *
- * @returns A tuple containing the created Viewpoints component and a function to update it.
- */
-export declare const viewpointsList: (state: ViewpointsUI, autoUpdate?: boolean) => [element: BUI.Table, update: (state?: Partial<ViewpointsUI> | undefined) => ViewpointsUI, currentState: () => ViewpointsUI];
-import * as BUI from "@thatopen/ui";
-import { Topic } from "../../Topic";
-import { Components } from "../../../../../core";
-interface DataStyles {
-    users: {
-        [email: string]: {
-            name: string;
-            picture?: string;
-        };
-    };
-}
-export interface TopicFormUI {
-    components: Components;
-    topic?: Topic;
-    onSubmit?: (topic: Topic) => void | Promise<void>;
-    onCancel?: () => void | Promise<void>;
-    styles?: Partial<DataStyles>;
-}
-export declare const topicFormTemplate: (state: TopicFormUI) => BUI.TemplateResult<1>;
-export {};
-import { BufferGeometry } from "three";
-import * as THREE from "three";
-export declare class TransformHelper {
-    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
-}
-import * as BUI from "@thatopen/ui";
-import { Components, Viewpoint } from "../../../../../core";
-import { Topic } from "../../Topic";
-interface ViewpointUIActions {
-    selectComponents: boolean;
-    colorizeComponent: boolean;
-    resetColors: boolean;
-    updateCamera: boolean;
-    delete: boolean;
-    unlink: boolean;
-}
-export interface ViewpointsUI {
-    components: Components;
-    topic?: Topic;
-    actions?: Partial<ViewpointUIActions>;
-    onViewpointEnter?: (viewpoint: Viewpoint) => void | Promise<void>;
-}
-export declare const viewpointsListTemplate: (state: ViewpointsUI) => BUI.TemplateResult<1>;
-export {};
+import { BCFTopics } from "../..";
+export declare const extensionsImporter: (manager: BCFTopics, extensionsXML: string) => void;
 import * as WEBIFC from "web-ifc";
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
@@ -4362,112 +4525,10 @@ export type IfcRelations = [
     typeof WEBIFC.IFCRELNESTS
 ];
 export type IfcRelation = IfcRelations[number];
-import * as BUI from "@thatopen/ui";
-import { Components } from "../../../../../core";
-import { Topic } from "../../Topic";
-interface DataStyles {
-    [name: string]: {
-        icon?: string;
-        style?: Record<string, string>;
-    };
-}
-interface UserStyles {
-    [email: string]: {
-        name: string;
-        picture?: string;
-    };
-}
-interface TopicDataStyles {
-    priorities?: DataStyles;
-    statuses?: DataStyles;
-    types?: DataStyles;
-    users?: UserStyles;
-}
-export interface BCFTopicsUI {
-    components: Components;
-    topics?: Iterable<Topic>;
-    dataStyles?: TopicDataStyles;
-    onTopicEnter?: (topic: Topic) => void | Promise<void>;
-}
-export declare const bcfTopicsListTemplate: (state: BCFTopicsUI) => BUI.TemplateResult<1>;
-export {};
-import * as BUI from "@thatopen/ui";
-import { Components, World } from "../../../../../core";
-import { Topic } from "../../Topic";
-interface DataStyles {
-    priorities: {
-        [name: string]: {
-            icon?: string;
-            style?: Record<string, string>;
-        };
-    };
-    statuses: {
-        [name: string]: {
-            icon?: string;
-            style?: Record<string, string>;
-        };
-    };
-    types: {
-        [name: string]: {
-            icon?: string;
-            style?: Record<string, string>;
-        };
-    };
-    users: {
-        [email: string]: {
-            name: string;
-            picture?: string;
-        };
-    };
-}
-interface TopicPanelActions {
-    update: boolean;
-    addComments: boolean;
-    addViewpoints: boolean;
-    linkViewpoints: boolean;
-    linkTopics: boolean;
-}
-export interface TopicPanelUI {
-    components: Components;
-    topic?: Topic;
-    styles?: Partial<DataStyles>;
-    onUpdateInformation?: (topic: Topic) => void | Promise<void>;
-    actions?: Partial<TopicPanelActions>;
-    world?: World;
-}
-export declare const topicPanelTemplate: (state: TopicPanelUI) => BUI.TemplateResult<1>;
-export {};
-import * as BUI from "@thatopen/ui";
-import { Topic } from "../../Topic";
-import { Viewpoint } from "../../../../../core";
-interface UserStyles {
-    [email: string]: {
-        name: string;
-        picture?: string;
-    };
-}
-interface TopicCommentsActions {
-    delete: boolean;
-}
-export interface TopicCommentsUI {
-    topic: Topic;
-    viewpoint?: Viewpoint;
-    styles?: UserStyles;
-    actions?: Partial<TopicCommentsActions>;
+import { BufferGeometry } from "three";
+import * as THREE from "three";
+export declare class TransformHelper {
+    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
 }
-export declare const topicCommentsTemplate: (state: TopicCommentsUI) => BUI.TemplateResult<1>;
-export {};
-import * as BUI from "@thatopen/ui";
-import { TopicCommentsUI } from "./src/template";
-/**
- * Creates a Topic Comments List component with the given UI state.
- *
- * @param state - The initial state of the Topic Comments List component.
- * @param autoUpdate - A flag indicating whether the component should automatically update based on events happening in the BCFTopic component.
- * Default value is 'true'.
- *
- * @returns A tuple containing the created Topic Comments List component and a function to update it.
- */
-export declare const topicComments: (state: TopicCommentsUI, autoUpdate?: boolean) => [element: BUI.Table, update: (state?: Partial<TopicCommentsUI> | undefined) => TopicCommentsUI, currentState: () => TopicCommentsUI];
 
 }