npm - @thatopen/components - Versions diffs - 2.0.18 → 2.0.19 - Mend

@thatopen/components 2.0.18 → 2.0.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/core/Components/index.d.ts +1 -1
package/dist/index.cjs +2 -2
package/dist/index.mjs +2 -2
package/dist/namespace.d.ts +1838 -1838
package/package.json +3 -3

package/dist/namespace.d.ts CHANGED Viewed

@@ -1,864 +1,1196 @@
 declare namespace OBC {
-import { Component, Disposable, Event } from "../Types";
+export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
+import * as THREE from "three";
+export declare function obbFromPoints(vertices: ArrayLike<number>): {
+    center: THREE.Vector3;
+    halfSizes: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    transformation: THREE.Matrix4;
+};
+import * as THREE from "three";
+import { Component, Components, Disposable, Event, World } from "../core";
 /**
- * The entry point of the Components library. It can create, delete and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
+ * Configuration interface for the VertexPicker component.
  */
-export declare class Components implements Disposable {
+export interface VertexPickerConfig {
     /**
-     * The version of the @thatopen/components library.
+     * 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.
      */
-    static readonly release = "2.0.18";
+    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<void>;
+    readonly onDisposed: Event<unknown>;
     /**
-     * The list of components created in this app.
-     * The keys are UUIDs and the values are instances of the components.
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
      */
-    readonly list: Map<string, Component>;
+    readonly onVertexFound: Event<THREE.Vector3>;
     /**
-     * If disabled, the animation loop will be stopped.
-     * Default value is false.
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
      */
-    enabled: boolean;
-    private _clock;
+    readonly onVertexLost: Event<THREE.Vector3>;
     /**
-     * Adds a component to the list of components.
-     * Throws an error if a component with the same UUID already exists.
-     *
-     * @param uuid - The unique identifier of the component.
-     * @param instance - The instance of the component to be added.
-     *
-     * @throws Will throw an error if a component with the same UUID already exists.
-     *
-     * @internal
+     * A reference to the Components instance associated with this VertexPicker.
      */
-    add(uuid: string, instance: Component): void;
+    components: Components;
     /**
-     * Retrieves a component instance by its constructor function.
-     * If the component does not exist in the list, it will be created and added.
+     * 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.
      *
-     * @template U - The type of the component to retrieve.
-     * @param Component - The constructor function of the component to retrieve.
+     * @param value - The new enabled state.
+     */
+    set enabled(value: boolean);
+    /**
+     * Gets the current enabled state of the VertexPicker.
      *
-     * @returns The instance of the requested component.
+     * @returns The current enabled state.
+     */
+    get enabled(): boolean;
+    /**
+     * Sets the configuration for the VertexPicker component.
      *
-     * @throws Will throw an error if a component with the same UUID already exists.
+     * @param value - A Partial object containing the configuration properties to update.
+     * The properties not provided in the value object will retain their current values.
      *
-     * @internal
+     * @example
+     * '''typescript
+     * vertexPicker.config = {
+     *   snapDistance: 0.5,
+     *   showOnlyVertex: true,
+     * };
+     * '''
      */
-    get<U extends Component>(Component: new (components: Components) => U): U;
-    constructor();
+    set config(value: Partial<VertexPickerConfig>);
     /**
-     * Initializes the Components instance.
-     * This method starts the animation loop, sets the enabled flag to true,
-     * and calls the update method.
+     * Gets the current configuration for the VertexPicker component.
      *
-     * @returns {void}
+     * @returns A copy of the current VertexPickerConfig object.
+     *
+     * @example
+     * '''typescript
+     * const currentConfig = vertexPicker.config;
+     * console.log(currentConfig.snapDistance); // Output: 0.25
+     * '''
      */
-    init(): void;
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Disposes the memory of all the components and tools of this instance of
-     * the library. A memory leak will be created if:
-     *
-     * - An instance of the library ends up out of scope and this function isn't
-     * called. This is especially relevant in Single Page Applications (React,
-     * Angular, Vue, etc).
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
      *
-     * - Any of the objects of this instance (meshes, geometries,materials, etc) is
-     * referenced by a reference type (object or array).
+     * @param world - The World instance to use for raycasting.
      *
-     * You can learn more about how Three.js handles memory leaks
-     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+     * @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'.
      */
-    dispose(): void;
-    private update;
-    private static setupBVH;
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
 }
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
+export type { InverseAttribute, RelationsMap } from "./src/types";
 /**
- * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
  */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+export declare class IfcRelationsIndexer extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * Return the UUIDs of all disposed components.
-     */
-    get(): Set<string>;
-    /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
-     *
-     * @param recursive - whether to recursively dispose the children of the mesh.
-     */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Disposes a geometry from memory.
+     * Event triggered when relations for a model have been indexed.
+     * This event provides the model's UUID and the relations map generated for that model.
      *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
+     * @property {string} modelID - The UUID of the model for which relations have been indexed.
+     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
+     * The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
      */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
-import { Components } from "../Components";
-/**
- * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
- */
-export declare class Raycasters extends Component implements Disposable {
+    readonly onRelationsIndexed: Event<{
+        modelID: string;
+        relationsMap: RelationsMap;
+    }>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Holds the relationship mappings for each model processed by the indexer.
+     * The structure is a map where each key is a model's UUID, and the value is another map.
+     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
+     * representing a specific relation type, and the value is an array of expressIDs of entities
+     * that are related through that relation type. This structure allows for efficient querying
+     * of entity relationships within a model.
      */
-    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+    readonly relationMaps: ModelsRelationMap;
     /** {@link Component.enabled} */
     enabled: boolean;
-    /**
-     * A Map that stores raycasters for each world.
-     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
-     */
-    list: Map<string, SimpleRaycaster>;
-    /** {@link Disposable.onDisposed} */
-    onDisposed: Event<unknown>;
+    private _relToAttributesMap;
+    private _inverseAttributes;
+    private _ifcRels;
     constructor(components: Components);
+    private onFragmentsDisposed;
+    private indexRelations;
     /**
-     * Retrieves a SimpleRaycaster instance for the given world.
-     * If a SimpleRaycaster instance already exists for the world, it will be returned.
-     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
+     * Adds a relation map to the model's relations map.
      *
-     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
-     * @returns The SimpleRaycaster instance for the given world.
+     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
+     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
+     *
+     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
      */
-    get(world: World): SimpleRaycaster;
+    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
     /**
-     * Deletes the SimpleRaycaster instance associated with the given world.
-     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
+     * Processes a given model to index its IFC entities relations based on predefined inverse attributes.
+     * This method iterates through each specified inverse attribute, retrieves the corresponding relations,
+     * and maps them in a structured way to facilitate quick access to related entities.
      *
-     * @param world - The world for which to delete the SimpleRaycaster instance.
-     * @returns {void}
+     * The process involves querying the model for each relation type associated with the inverse attributes
+     * and updating the internal relationMaps with the relationships found. This map is keyed by the model's UUID
+     * and contains a nested map where each key is an entity's expressID and its value is another map.
+     * This inner map's keys are the indices of the inverse attributes, and its values are arrays of expressIDs
+     * of entities that are related through that attribute.
+     *
+     * @param model The 'FragmentsGroup' model to be processed. It must have properties loaded.
+     * @returns A promise that resolves to the relations map for the processed model. This map is a detailed
+     * representation of the relations indexed by entity expressIDs and relation types.
+     * @throws An error if the model does not have properties loaded.
      */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}
-import { Component, Disposable, World, Event } from "../Types";
-import { GridConfig, SimpleGrid } from "./src";
-import { Components } from "../Components";
-/**
- * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
- */
-export declare class Grids extends Component implements Disposable {
+    process(model: FragmentsGroup): Promise<RelationsMap>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Processes a given model from a WebIfc API to index its IFC entities relations.
+     *
+     * @param ifcApi - The WebIfc API instance from which to retrieve the model's properties.
+     * @param modelID - The unique identifier of the model within the WebIfc API.
+     * @returns A promise that resolves to the relations map for the processed model.
+     *          This map is a detailed representation of the relations indexed by entity expressIDs and relation types.
      */
-    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
+    processFromWebIfc(ifcApi: WEBIFC.IfcAPI, modelID: number): Promise<RelationsMap>;
     /**
-     * A map of world UUIDs to their corresponding grid instances.
+     * Retrieves the relations of a specific entity within a model based on the given relation name.
+     * This method searches the indexed relation maps for the specified model and entity,
+     * returning the IDs of related entities if a match is found.
+     *
+     * @param model The 'FragmentsGroup' model containing the entity.
+     * @param expressID The unique identifier of the entity within the model.
+     * @param relationName The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
+     * @returns An array of express IDs representing the related entities, or 'null' if no relations are found
+     * or the specified relation name is not indexed.
      */
-    list: Map<string, SimpleGrid>;
+    getEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute): number[] | null;
     /**
-     * The default configuration for grid creation.
+     * Serializes the relations of a given relation map into a JSON string.
+     * This method iterates through the relations in the given map, organizing them into a structured object where each key is an expressID of an entity,
+     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
+     * The resulting object is then serialized into a JSON string.
+     *
+     * @param relationMap - The map of relations to be serialized. The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
+     * @returns A JSON string representing the serialized relations of the given relation map.
      */
-    config: Required<GridConfig>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    serializeRelations(relationMap: RelationsMap): string;
     /**
-     * Creates a new grid for the given world.
-     * Throws an error if a grid already exists for the world.
-     *
-     * @param world - The world to create the grid for.
-     * @returns The newly created grid.
+     * Serializes the relations of a specific model into a JSON string.
+     * This method iterates through the relations indexed for the given model,
+     * organizing them into a structured object where each key is an expressID of an entity,
+     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
+     * The resulting object is then serialized into a JSON string.
      *
-     * @throws Will throw an error if a grid already exists for the given world.
+     * @param model The 'FragmentsGroup' model whose relations are to be serialized.
+     * @returns A JSON string representing the serialized relations of the specified model.
+     * If the model has no indexed relations, 'null' is returned.
      */
-    create(world: World): SimpleGrid;
+    serializeModelRelations(model: FragmentsGroup): string | null;
     /**
-     * Deletes the grid associated with the given world.
-     * If a grid does not exist for the given world, this method does nothing.
+     * Serializes all relations of every model processed by the indexer into a JSON string.
+     * This method iterates through each model's relations indexed in 'relationMaps', organizing them
+     * into a structured JSON object. Each top-level key in this object corresponds to a model's UUID,
+     * and its value is another object mapping entity expressIDs to their related entities, categorized
+     * by relation types. The structure facilitates easy access to any entity's relations across all models.
      *
-     * @param world - The world for which to delete the grid.
+     * @returns A JSON string representing the serialized relations of all models processed by the indexer.
+     *          If no relations have been indexed, an empty object is returned as a JSON string.
+     */
+    serializeAllRelations(): string;
+    /**
+     * Converts a JSON string representing relations between entities into a structured map.
+     * This method parses the JSON string to reconstruct the relations map that indexes
+     * entity relations by their express IDs. The outer map keys are the express IDs of entities,
+     * and the values are maps where each key is a relation type ID and its value is an array
+     * of express IDs of entities related through that relation type.
      *
-     * @remarks
-     * This method will dispose of the grid and remove it from the internal list.
-     * If the world is disposed before calling this method, the grid will be automatically deleted.
+     * @param json The JSON string to be parsed into the relations map.
+     * @returns A 'Map' where the key is the express ID of an entity as a number, and the value
+     * is another 'Map'. This inner map's key is the relation type ID as a number, and its value
+     * is an array of express IDs (as numbers) of entities related through that relation type.
      */
-    delete(world: World): void;
+    getRelationsMapFromJSON(json: string): RelationsMap;
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import * as THREE from "three";
-import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
-import { SimplePlane } from "./src";
-import { Components } from "../Components";
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Disposable, Event, Components } from "../../core";
 /**
- * A lightweight component to easily create, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
- *
- * @param components - the instance of {@link Components} used.
- * E.g. {@link SimplePlane}.
+ * Types for boolean properties in IFC schema.
  */
-export declare class Clipper extends Component implements Createable, Disposable, Hideable {
+export type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
+/**
+ * Types for string properties in IFC schema.
+ */
+export type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
+/**
+ * Types for numeric properties in IFC schema.
+ */
+export type NumericPropTypes = "IfcInteger" | "IfcReal";
+/**
+ * Interface representing a map of changed entities in a model. The keys are model UUIDs, and the values are sets of express IDs of changed entities.
+ */
+export interface ChangeMap {
+    [modelID: string]: Set<number>;
+}
+/**
+ * Interface representing a map of attribute listeners. The keys are model UUIDs, and the values are objects with express IDs as keys, and objects with attribute names as keys, and Event objects as values.
+ */
+export interface AttributeListener {
+    [modelID: string]: {
+        [expressID: number]: {
+            [attributeName: string]: Event<String | Boolean | Number>;
+        };
+    };
+}
+/**
+ * Component to manage and edit properties and Psets in IFC files.
+ */
+export declare class IfcPropertiesManager extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onBeforeDrag: Event<void>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onAfterDrag: Event<void>;
+    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Event that fires when the user starts creating a clipping plane.
+     * Event triggered when a file is requested for export.
      */
-    readonly onBeforeCreate: Event<unknown>;
+    readonly onRequestFile: Event<unknown>;
     /**
-     * Event that fires when the user cancels the creation of a clipping plane.
+     * ArrayBuffer containing the IFC data to be exported.
      */
-    readonly onBeforeCancel: Event<unknown>;
+    ifcToExport: ArrayBuffer | null;
     /**
-     * Event that fires after the user cancels the creation of a clipping plane.
+     * Event triggered when an element is added to a Pset.
      */
-    readonly onAfterCancel: Event<unknown>;
+    readonly onElementToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        elementID: number;
+    }>;
     /**
-     * Event that fires when the user starts deleting a clipping plane.
+     * Event triggered when a property is added to a Pset.
      */
-    readonly onBeforeDelete: Event<unknown>;
+    readonly onPropToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        propID: number;
+    }>;
     /**
-     * Event that fires after a clipping plane has been created.
-     * @param plane - The newly created clipping plane.
+     * Event triggered when a Pset is removed.
      */
-    readonly onAfterCreate: Event<SimplePlane>;
+    readonly onPsetRemoved: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+    }>;
     /**
-     * Event that fires after a clipping plane has been deleted.
-     * @param plane - The deleted clipping plane.
+     * Event triggered when data in the model changes.
      */
-    readonly onAfterDelete: Event<SimplePlane>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    readonly onDataChanged: Event<{
+        model: FragmentsGroup;
+        expressID: number;
+    }>;
     /**
-     * Whether to force the clipping plane to be orthogonal in the Y direction
-     * (up). This is desirable when clipping a building horizontally and a
-     * clipping plane is created in its roof, which might have a slight
-     * slope for draining purposes.
+     * Configuration for the WebAssembly module.
      */
-    orthogonalY: boolean;
+    wasm: {
+        path: string;
+        absolute: boolean;
+    };
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * The tolerance that determines whether an almost-horizontal clipping plane
-     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
-     * has to be 'true' for this to apply.
+     * Map of attribute listeners.
      */
-    toleranceOrthogonalY: number;
+    attributeListeners: AttributeListener;
     /**
-     * The type of clipping plane to be created.
-     * Default is {@link SimplePlane}.
+     * The currently selected model.
      */
-    Type: new (...args: any) => SimplePlane;
+    selectedModel?: FragmentsGroup;
     /**
-     * A list of all the clipping planes created by this component.
+     * Map of changed entities in the model.
      */
-    list: SimplePlane[];
-    /** The material used in all the clipping planes. */
-    private _material;
-    private _size;
-    private _enabled;
-    private _visible;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The material of the clipping plane representation. */
-    get material(): THREE.MeshBasicMaterial;
-    /** The material of the clipping plane representation. */
-    set material(material: THREE.MeshBasicMaterial);
-    /** The size of the geometric representation of the clippings planes. */
-    get size(): number;
-    /** The size of the geometric representation of the clippings planes. */
-    set size(size: number);
+    changeMap: ChangeMap;
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@link Createable.create} */
-    create(world: World): void;
     /**
-     * Creates a plane in a certain place and with a certain orientation,
-     * without the need of the mouse.
+     * Static method to retrieve the IFC schema from a given model.
      *
-     * @param world - the world where this plane should be created.
-     * @param normal - the orientation of the clipping plane.
-     * @param point - the position of the clipping plane.
-     * navigation.
+     * @param model - The FragmentsGroup model from which to retrieve the IFC schema.
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @returns The IFC schema associated with the given model.
      */
-    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): SimplePlane;
+    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
     /**
-     * {@link Createable.delete}
+     * Method to set properties data in the model.
      *
-     * @param world - the world where the plane to delete is.
-     * @param plane - the plane to delete. If undefined, the first plane
-     * found under the cursor will be deleted.
+     * @param model - The FragmentsGroup model in which to set the properties.
+     * @param dataToSave - An array of objects representing the properties to be saved.
+     * Each object must have an 'expressID' property, which is the express ID of the entity in the model.
+     * The rest of the properties will be set as the properties of the entity.
+     *
+     * @returns {Promise<void>} A promise that resolves when all the properties have been set.
+     *
+     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'dataToSave' array.
      */
-    delete(world: World, plane?: SimplePlane): void;
-    /** Deletes all the existing clipping planes. */
-    deleteAll(): void;
-    private deletePlane;
-    private pickPlane;
-    private getAllPlaneMeshes;
-    private createPlaneFromIntersection;
-    private getWorldNormal;
-    private normalizePlaneDirectionY;
-    private newPlane;
-    private updateMaterialsAndPlanes;
-    private _onStartDragging;
-    private _onEndDragging;
-}
-import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
-import { Components } from "../Components";
-import { SimpleWorld } from "./src";
-/**
- * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
- */
-export declare class Worlds extends Component implements Updateable, Disposable {
+    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Creates a new Property Set (Pset) in the given model.
+     *
+     * @param model - The FragmentsGroup model in which to create the Pset.
+     * @param name - The name of the Pset.
+     * @param description - (Optional) The description of the Pset.
+     *
+     * @returns A promise that resolves with an object containing the newly created Pset and its relation.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
+        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
+        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
+    }>;
     /**
-     * An event that is triggered when a new world is created.
-     * The event passes the newly created world as a parameter.
+     * Removes a Property Set (Pset) from the given model.
+     *
+     * @param model - The FragmentsGroup model from which to remove the Pset.
+     * @param psetID - The express IDs of the Psets to be removed.
+     *
+     * @returns {Promise<void>} A promise that resolves when all the Psets have been removed.
+     *
+     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'psetID' array.
+     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
+     * @throws Will throw an error if no relation is found between the Pset and the model.
      */
-    readonly onWorldCreated: Event<World>;
+    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
     /**
-     * An event that is triggered when a world is deleted.
-     * The event passes the UUID of the deleted world as a parameter.
+     * Creates a new single-value property of type string in the given model.
+     *
+     * @param model - The FragmentsGroup model in which to create the property.
+     * @param type - The type of the property value. Must be a string property type.
+     * @param name - The name of the property.
+     * @param value - The value of the property. Must be a string.
+     *
+     * @returns The newly created single-value property.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    readonly onWorldDeleted: Event<string>;
+    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
     /**
-     * A collection of worlds managed by this component.
-     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
+     * Creates a new single-value property of type numeric in the given model.
+     *
+     * @param model - The FragmentsGroup model in which to create the property.
+     * @param type - The type of the property value. Must be a numeric property type.
+     * @param name - The name of the property.
+     * @param value - The value of the property. Must be a number.
+     *
+     * @returns The newly created single-value property.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    list: Map<string, World>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
     /**
-     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
+     * Creates a new single-value property of type boolean in the given model.
      *
-     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
-     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
-     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
+     * @param model - The FragmentsGroup model in which to create the property.
+     * @param type - The type of the property value. Must be a boolean property type.
+     * @param name - The name of the property.
+     * @param value - The value of the property. Must be a boolean.
      *
-     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
+     * @returns The newly created single-value property.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
+    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
     /**
-     * Deletes a world from the list of worlds.
+     * Removes a property from a Property Set (Pset) in the given model.
      *
-     * @param {World} world - The world to be deleted.
+     * @param model - The FragmentsGroup model from which to remove the property.
+     * @param psetID - The express ID of the Pset from which to remove the property.
+     * @param propID - The express ID of the property to be removed.
      *
-     * @throws {Error} - Throws an error if the provided world is not found in the list.
+     * @returns {Promise<void>} A promise that resolves when the property has been removed.
      *
-     * @returns {void}
+     * @throws Will throw an error if the Pset or the property to be removed are not found in the model.
+     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
      */
-    delete(world: World): void;
+    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
+    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
     /**
-     * Disposes of the Worlds component and all its managed worlds.
-     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
-     * and triggers the onDisposed event.
+     * Adds elements to a Property Set (Pset) in the given model.
      *
-     * @returns {void}
+     * @param model - The FragmentsGroup model in which to add the elements.
+     * @param psetID - The express ID of the Pset to which to add the elements.
+     * @param elementID - The express IDs of the elements to be added.
+     *
+     * @returns {Promise<void>} A promise that resolves when all the elements have been added.
+     *
+     * @throws Will throw an error if the Pset or the elements to be added are not found in the model.
+     * @throws Will throw an error if the Pset to be added to is not of type 'IFCPROPERTYSET'.
+     * @throws Will throw an error if no relation is found between the Pset and the model.
      */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(delta?: number): void | Promise<void>;
+    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
+    /**
+     * Saves the changes made to the model to a new IFC file.
+     *
+     * @param model - The FragmentsGroup model from which to save the changes.
+     * @param ifcToSaveOn - The Uint8Array representing the original IFC file.
+     *
+     * @returns A promise that resolves with the modified IFC data as a Uint8Array.
+     *
+     * @throws Will throw an error if any issues occur during the saving process.
+     */
+    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
+    /**
+     * 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.
+     *
+     * @param model - The FragmentsGroup model in which to set the attribute listener.
+     * @param expressID - The express ID of the entity for which to set the listener.
+     * @param attributeName - The name of the attribute for which to set the listener.
+     *
+     * @returns The event that will be triggered when the attribute's value changes.
+     *
+     * @throws Will throw an error if the entity with the given expressID doesn't exist.
+     * @throws Will throw an error if the attribute is an array or null, and it can't have a listener.
+     * @throws Will throw an error if the attribute has a badly defined handle.
+     */
+    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
+    private increaseMaxID;
+    private newGUID;
+    private getOwnerHistory;
+    private registerChange;
+    private newSingleProperty;
 }
-import { MiniMap } from "./src";
-import { Component, Updateable, World, Event, Disposable } from "../Types";
-import { Components } from "../Components";
+import * as WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
 /**
- * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
+ * 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 MiniMaps extends Component implements Updateable, Disposable {
+export declare class IfcJsonExporter extends Component {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
     /** {@link Component.enabled} */
     enabled: boolean;
-    /**
-     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
-     */
-    list: Map<string, MiniMap>;
     constructor(components: Components);
     /**
-     * Creates a new {@link MiniMap} instance associated with the given world.
-     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
-     *
-     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
-     * @returns The newly created {@link MiniMap} instance.
-     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
-     */
-    create(world: World): MiniMap;
-    /**
-     * Deletes a {@link MiniMap} instance associated with the given world ID.
-     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
-     *
-     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
-     * @returns {void}
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
      */
-    delete(id: string): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
+import * as THREE from "three";
 import { Components } from "../Components";
-import { MeshCullerRenderer, CullerRendererSettings } from "./src";
-import { Component, Event, Disposable, World } from "../Types";
+import { Component } from "../Types";
 /**
- * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
+ * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
  */
-export declare class Cullers extends Component implements Disposable {
+export declare class Disposer extends Component {
+    private _disposedComponents;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
+    constructor(components: Components);
     /**
-     * An event that is triggered when the Cullers component is disposed.
+     * Return the UUIDs of all disposed components.
      */
-    readonly onDisposed: Event<unknown>;
-    private _enabled;
+    get(): Set<string>;
     /**
-     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
-     */
-    list: Map<string, MeshCullerRenderer>;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
+     * Removes a mesh, its geometry and its materials from memory. If you are
+     * using any of these in other parts of the application, make sure that you
+     * remove them from the mesh before disposing it.
+     *
+     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
+     * to remove.
+     *
+     * @param materials - whether to dispose the materials of the mesh.
+     *
+     * @param recursive - whether to recursively dispose the children of the mesh.
+     */
+    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
+    /**
+     * Disposes a geometry from memory.
+     *
+     * @param geometry - the
+     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+     * to remove.
+     */
+    disposeGeometry(geometry: THREE.BufferGeometry): void;
+    private disposeGeometryAndMaterials;
+    private disposeChildren;
+    private static disposeMaterial;
+}
+import { Component, Disposable, World, Event } from "../Types";
+import { SimpleRaycaster } from "./src";
+import { Components } from "../Components";
+/**
+ * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
+ */
+export declare class Raycasters extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
     /** {@link Component.enabled} */
-    set enabled(value: boolean);
+    enabled: boolean;
+    /**
+     * A Map that stores raycasters for each world.
+     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     */
+    list: Map<string, SimpleRaycaster>;
+    /** {@link Disposable.onDisposed} */
+    onDisposed: Event<unknown>;
     constructor(components: Components);
     /**
-     * Creates a new MeshCullerRenderer for the given world.
-     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
-     *
-     * @param world - The world for which to create the MeshCullerRenderer.
-     * @param config - Optional configuration settings for the MeshCullerRenderer.
+     * Retrieves a SimpleRaycaster instance for the given world.
+     * If a SimpleRaycaster instance already exists for the world, it will be returned.
+     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
      *
-     * @returns The newly created or existing MeshCullerRenderer for the given world.
+     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
+     * @returns The SimpleRaycaster instance for the given world.
      */
-    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
+    get(world: World): SimpleRaycaster;
     /**
-     * Deletes the MeshCullerRenderer associated with the given world.
-     * If a MeshCullerRenderer exists for the given world, it will be disposed and removed from the list.
-     *
-     * @param world - The world for which to delete the MeshCullerRenderer.
+     * Deletes the SimpleRaycaster instance associated with the given world.
+     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
      *
+     * @param world - The world for which to delete the SimpleRaycaster instance.
      * @returns {void}
      */
     delete(world: World): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import * as THREE from "three";
-import { Components } from "../Components";
-import { SimpleCamera } from "..";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+import { Component, Disposable, Event } from "../Types";
 /**
- * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
+ * The entry point of the Components library. It can create, delete and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
  */
-export declare class OrthoPerspectiveCamera extends SimpleCamera {
+export declare class Components implements Disposable {
     /**
-     * A ProjectionManager instance that manages the projection modes of the camera.
+     * The version of the @thatopen/components library.
      */
-    readonly projection: ProjectionManager;
+    static readonly release = "2.0.19";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<void>;
     /**
-     * A THREE.OrthographicCamera instance that represents the orthographic camera.
-     * This camera is used when the projection mode is set to orthographic.
+     * The list of components created in this app.
+     * The keys are UUIDs and the values are instances of the components.
      */
-    readonly threeOrtho: THREE.OrthographicCamera;
+    readonly list: Map<string, Component>;
     /**
-     * A THREE.PerspectiveCamera instance that represents the perspective camera.
-     * This camera is used when the projection mode is set to perspective.
+     * If disabled, the animation loop will be stopped.
+     * Default value is false.
      */
-    readonly threePersp: THREE.PerspectiveCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    protected _mode: NavigationMode | null;
-    private previousSize;
+    enabled: boolean;
+    private _clock;
     /**
-     * Getter for the current navigation mode.
-     * Throws an error if the mode is not found or the camera is not initialized.
+     * Adds a component to the list of components.
+     * Throws an error if a component with the same UUID already exists.
      *
-     * @returns {NavigationMode} The current navigation mode.
+     * @param uuid - The unique identifier of the component.
+     * @param instance - The instance of the component to be added.
      *
-     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
+     * @throws Will throw an error if a component with the same UUID already exists.
+     *
+     * @internal
      */
-    get mode(): NavigationMode;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    add(uuid: string, instance: Component): void;
     /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
+     * Retrieves a component instance by its constructor function.
+     * If the component does not exist in the list, it will be created and added.
      *
-     * @param mode - The {@link NavigationMode} to set.
+     * @template U - The type of the component to retrieve.
+     * @param Component - The constructor function of the component to retrieve.
+     *
+     * @returns The instance of the requested component.
+     *
+     * @throws Will throw an error if a component with the same UUID already exists.
+     *
+     * @internal
      */
-    set(mode: NavModeID): void;
+    get<U extends Component>(Component: new (components: Components) => U): U;
+    constructor();
     /**
-     * Make the camera view fit all the specified meshes.
+     * Initializes the Components instance.
+     * This method starts the animation loop, sets the enabled flag to true,
+     * and calls the update method.
      *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
+     * @returns {void}
      */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    init(): void;
     /**
-     * Allows or prevents all user input.
+     * Disposes the memory of all the components and tools of this instance of
+     * the library. A memory leak will be created if:
+     *
+     * - An instance of the library ends up out of scope and this function isn't
+     * called. This is especially relevant in Single Page Applications (React,
+     * Angular, Vue, etc).
+     *
+     * - Any of the objects of this instance (meshes, geometries,materials, etc) is
+     * referenced by a reference type (object or array).
+     *
+     * You can learn more about how Three.js handles memory leaks
+     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
      *
-     * @param active - whether to enable or disable user inputs.
      */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
-}
-import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
-import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
+    dispose(): void;
+    private update;
+    private static setupBVH;
 }
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
+import { MiniMap } from "./src";
+import { Component, Updateable, World, Event, Disposable } from "../Types";
+import { Components } from "../Components";
 /**
- * Configuration interface for the VertexPicker component.
+ * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
  */
-export interface VertexPickerConfig {
+export declare class MiniMaps extends Component implements Updateable, Disposable {
     /**
-     * If true, only vertices will be picked, not the closest point on the face.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    showOnlyVertex: boolean;
+    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * The maximum distance for snapping to a vertex.
+     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
      */
-    snapDistance: number;
+    list: Map<string, MiniMap>;
+    constructor(components: Components);
     /**
-     * The HTML element to use for previewing the picked vertex.
+     * Creates a new {@link MiniMap} instance associated with the given world.
+     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
+     *
+     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
+     * @returns The newly created {@link MiniMap} instance.
+     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
      */
-    previewElement: HTMLElement;
+    create(world: World): MiniMap;
+    /**
+     * Deletes a {@link MiniMap} instance associated with the given world ID.
+     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
+     *
+     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
+     * @returns {void}
+     */
+    delete(id: string): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(): void;
 }
+import * as THREE from "three";
+import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
+import { SimplePlane } from "./src";
+import { Components } from "../Components";
 /**
- * A class that provides functionality for picking vertices in a 3D scene.
+ * A lightweight component to easily create, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
+ *
+ * @param components - the instance of {@link Components} used.
+ * E.g. {@link SimplePlane}.
  */
-export declare class VertexPicker extends Component implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+export declare class Clipper extends Component implements Createable, Disposable, Hideable {
     /**
-     * An event that is triggered when a vertex is found.
-     * The event passes a THREE.Vector3 representing the position of the found vertex.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    readonly onVertexFound: Event<THREE.Vector3>;
+    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
+    /** Event that fires when the user starts dragging a clipping plane. */
+    readonly onBeforeDrag: Event<void>;
+    /** Event that fires when the user stops dragging a clipping plane. */
+    readonly onAfterDrag: Event<void>;
     /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
+     * Event that fires when the user starts creating a clipping plane.
      */
-    readonly onVertexLost: Event<THREE.Vector3>;
+    readonly onBeforeCreate: Event<unknown>;
     /**
-     * A reference to the Components instance associated with this VertexPicker.
+     * Event that fires when the user cancels the creation of a clipping plane.
      */
-    components: Components;
+    readonly onBeforeCancel: Event<unknown>;
     /**
-     * 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.
+     * Event that fires after the user cancels the creation of a clipping plane.
      */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
+    readonly onAfterCancel: Event<unknown>;
     /**
-     * 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.
+     * Event that fires when the user starts deleting a clipping plane.
      */
-    set enabled(value: boolean);
+    readonly onBeforeDelete: Event<unknown>;
     /**
-     * Gets the current enabled state of the VertexPicker.
-     *
-     * @returns The current enabled state.
+     * Event that fires after a clipping plane has been created.
+     * @param plane - The newly created clipping plane.
      */
-    get enabled(): boolean;
+    readonly onAfterCreate: Event<SimplePlane>;
     /**
-     * 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,
-     * };
-     * '''
+     * Event that fires after a clipping plane has been deleted.
+     * @param plane - The deleted clipping plane.
      */
-    set config(value: Partial<VertexPickerConfig>);
+    readonly onAfterDelete: Event<SimplePlane>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * 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
-     * '''
+     * Whether to force the clipping plane to be orthogonal in the Y direction
+     * (up). This is desirable when clipping a building horizontally and a
+     * clipping plane is created in its roof, which might have a slight
+     * slope for draining purposes.
      */
-    get config(): Partial<VertexPickerConfig>;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    orthogonalY: boolean;
+    /**
+     * The tolerance that determines whether an almost-horizontal clipping plane
+     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
+     * has to be 'true' for this to apply.
+     */
+    toleranceOrthogonalY: number;
+    /**
+     * The type of clipping plane to be created.
+     * Default is {@link SimplePlane}.
+     */
+    Type: new (...args: any) => SimplePlane;
+    /**
+     * A list of all the clipping planes created by this component.
+     */
+    list: SimplePlane[];
+    /** The material used in all the clipping planes. */
+    private _material;
+    private _size;
+    private _enabled;
+    private _visible;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The material of the clipping plane representation. */
+    get material(): THREE.MeshBasicMaterial;
+    /** The material of the clipping plane representation. */
+    set material(material: THREE.MeshBasicMaterial);
+    /** The size of the geometric representation of the clippings planes. */
+    get size(): number;
+    /** The size of the geometric representation of the clippings planes. */
+    set size(size: number);
+    constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /** {@link Createable.create} */
+    create(world: World): void;
     /**
-     * Performs the vertex picking operation based on the current state of the VertexPicker.
-     *
-     * @param world - The World instance to use for raycasting.
+     * Creates a plane in a certain place and with a certain orientation,
+     * without the need of the mouse.
      *
-     * @returns The current picked point, or null if no point is picked.
+     * @param world - the world where this plane should be created.
+     * @param normal - the orientation of the clipping plane.
+     * @param point - the position of the clipping plane.
+     * navigation.
+     */
+    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): SimplePlane;
+    /**
+     * {@link Createable.delete}
      *
-     * @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'.
+     * @param world - the world where the plane to delete is.
+     * @param plane - the plane to delete. If undefined, the first plane
+     * found under the cursor will be deleted.
      */
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
+    delete(world: World, plane?: SimplePlane): void;
+    /** Deletes all the existing clipping planes. */
+    deleteAll(): void;
+    private deletePlane;
+    private pickPlane;
+    private getAllPlaneMeshes;
+    private createPlaneFromIntersection;
+    private getWorldNormal;
+    private normalizePlaneDirectionY;
+    private newPlane;
+    private updateMaterialsAndPlanes;
+    private _onStartDragging;
+    private _onEndDragging;
 }
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Disposable, Event, Component, Components } from "../../core";
-import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
-export type { InverseAttribute, RelationsMap } from "./src/types";
+import { Component, Disposable, World, Event } from "../Types";
+import { GridConfig, SimpleGrid } from "./src";
+import { Components } from "../Components";
 /**
- * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
+ * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
  */
-export declare class IfcRelationsIndexer extends Component implements Disposable {
+export declare class Grids extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
     /**
-     * Event triggered when relations for a model have been indexed.
-     * This event provides the model's UUID and the relations map generated for that model.
-     *
-     * @property {string} modelID - The UUID of the model for which relations have been indexed.
-     * @property {RelationsMap} relationsMap - The relations map generated for the specified model.
-     * The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
+     * A map of world UUIDs to their corresponding grid instances.
      */
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
+    list: Map<string, SimpleGrid>;
     /**
-     * Holds the relationship mappings for each model processed by the indexer.
-     * The structure is a map where each key is a model's UUID, and the value is another map.
-     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
-     * representing a specific relation type, and the value is an array of expressIDs of entities
-     * that are related through that relation type. This structure allows for efficient querying
-     * of entity relationships within a model.
+     * The default configuration for grid creation.
      */
-    readonly relationMaps: ModelsRelationMap;
+    config: Required<GridConfig>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /** {@link Component.enabled} */
     enabled: boolean;
-    private _relToAttributesMap;
-    private _inverseAttributes;
-    private _ifcRels;
     constructor(components: Components);
-    private onFragmentsDisposed;
-    private indexRelations;
     /**
-     * Adds a relation map to the model's relations map.
+     * Creates a new grid for the given world.
+     * Throws an error if a grid already exists for the world.
      *
-     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
-     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
+     * @param world - The world to create the grid for.
+     * @returns The newly created grid.
      *
-     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
+     * @throws Will throw an error if a grid already exists for the given world.
      */
-    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
+    create(world: World): SimpleGrid;
     /**
-     * Processes a given model to index its IFC entities relations based on predefined inverse attributes.
-     * This method iterates through each specified inverse attribute, retrieves the corresponding relations,
-     * and maps them in a structured way to facilitate quick access to related entities.
+     * Deletes the grid associated with the given world.
+     * If a grid does not exist for the given world, this method does nothing.
      *
-     * The process involves querying the model for each relation type associated with the inverse attributes
-     * and updating the internal relationMaps with the relationships found. This map is keyed by the model's UUID
-     * and contains a nested map where each key is an entity's expressID and its value is another map.
-     * This inner map's keys are the indices of the inverse attributes, and its values are arrays of expressIDs
-     * of entities that are related through that attribute.
+     * @param world - The world for which to delete the grid.
      *
-     * @param model The 'FragmentsGroup' model to be processed. It must have properties loaded.
-     * @returns A promise that resolves to the relations map for the processed model. This map is a detailed
-     * representation of the relations indexed by entity expressIDs and relation types.
-     * @throws An error if the model does not have properties loaded.
+     * @remarks
+     * This method will dispose of the grid and remove it from the internal list.
+     * If the world is disposed before calling this method, the grid will be automatically deleted.
      */
-    process(model: FragmentsGroup): Promise<RelationsMap>;
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+}
+import * as THREE from "three";
+import { Components } from "../Components";
+import { SimpleCamera } from "..";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+/**
+ * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
+ */
+export declare class OrthoPerspectiveCamera extends SimpleCamera {
     /**
-     * Processes a given model from a WebIfc API to index its IFC entities relations.
-     *
-     * @param ifcApi - The WebIfc API instance from which to retrieve the model's properties.
-     * @param modelID - The unique identifier of the model within the WebIfc API.
-     * @returns A promise that resolves to the relations map for the processed model.
-     *          This map is a detailed representation of the relations indexed by entity expressIDs and relation types.
+     * A ProjectionManager instance that manages the projection modes of the camera.
      */
-    processFromWebIfc(ifcApi: WEBIFC.IfcAPI, modelID: number): Promise<RelationsMap>;
+    readonly projection: ProjectionManager;
     /**
-     * Retrieves the relations of a specific entity within a model based on the given relation name.
-     * This method searches the indexed relation maps for the specified model and entity,
-     * returning the IDs of related entities if a match is found.
-     *
-     * @param model The 'FragmentsGroup' model containing the entity.
-     * @param expressID The unique identifier of the entity within the model.
-     * @param relationName The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
-     * @returns An array of express IDs representing the related entities, or 'null' if no relations are found
-     * or the specified relation name is not indexed.
+     * A THREE.OrthographicCamera instance that represents the orthographic camera.
+     * This camera is used when the projection mode is set to orthographic.
      */
-    getEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute): number[] | null;
+    readonly threeOrtho: THREE.OrthographicCamera;
     /**
-     * Serializes the relations of a given relation map into a JSON string.
-     * This method iterates through the relations in the given map, organizing them into a structured object where each key is an expressID of an entity,
-     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
-     * The resulting object is then serialized into a JSON string.
-     *
-     * @param relationMap - The map of relations to be serialized. The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
-     * @returns A JSON string representing the serialized relations of the given relation map.
-     */
-    serializeRelations(relationMap: RelationsMap): string;
+     * A THREE.PerspectiveCamera instance that represents the perspective camera.
+     * This camera is used when the projection mode is set to perspective.
+     */
+    readonly threePersp: THREE.PerspectiveCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    protected _mode: NavigationMode | null;
+    private previousSize;
     /**
-     * Serializes the relations of a specific model into a JSON string.
-     * This method iterates through the relations indexed for the given model,
-     * organizing them into a structured object where each key is an expressID of an entity,
-     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
-     * The resulting object is then serialized into a JSON string.
+     * Getter for the current navigation mode.
+     * Throws an error if the mode is not found or the camera is not initialized.
      *
-     * @param model The 'FragmentsGroup' model whose relations are to be serialized.
-     * @returns A JSON string representing the serialized relations of the specified model.
-     * If the model has no indexed relations, 'null' is returned.
+     * @returns {NavigationMode} The current navigation mode.
+     *
+     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
      */
-    serializeModelRelations(model: FragmentsGroup): string | null;
+    get mode(): NavigationMode;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Serializes all relations of every model processed by the indexer into a JSON string.
-     * This method iterates through each model's relations indexed in 'relationMaps', organizing them
-     * into a structured JSON object. Each top-level key in this object corresponds to a model's UUID,
-     * and its value is another object mapping entity expressIDs to their related entities, categorized
-     * by relation types. The structure facilitates easy access to any entity's relations across all models.
+     * Sets a new {@link NavigationMode} and disables the previous one.
      *
-     * @returns A JSON string representing the serialized relations of all models processed by the indexer.
-     *          If no relations have been indexed, an empty object is returned as a JSON string.
+     * @param mode - The {@link NavigationMode} to set.
      */
-    serializeAllRelations(): string;
+    set(mode: NavModeID): void;
     /**
-     * Converts a JSON string representing relations between entities into a structured map.
-     * This method parses the JSON string to reconstruct the relations map that indexes
-     * entity relations by their express IDs. The outer map keys are the express IDs of entities,
-     * and the values are maps where each key is a relation type ID and its value is an array
-     * of express IDs of entities related through that relation type.
+     * Make the camera view fit all the specified meshes.
      *
-     * @param json The JSON string to be parsed into the relations map.
-     * @returns A 'Map' where the key is the express ID of an entity as a number, and the value
-     * is another 'Map'. This inner map's key is the relation type ID as a number, and its value
-     * is an array of express IDs (as numbers) of entities related through that relation type.
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
      */
-    getRelationsMapFromJSON(json: string): RelationsMap;
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    /**
+     * Allows or prevents all user input.
+     *
+     * @param active - whether to enable or disable user inputs.
+     */
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoPerspCameraAspect;
+}
+import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
+import { Components } from "../Components";
+import { SimpleWorld } from "./src";
+/**
+ * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
+ */
+export declare class Worlds extends Component implements Updateable, Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * An event that is triggered when a new world is created.
+     * The event passes the newly created world as a parameter.
+     */
+    readonly onWorldCreated: Event<World>;
+    /**
+     * An event that is triggered when a world is deleted.
+     * The event passes the UUID of the deleted world as a parameter.
+     */
+    readonly onWorldDeleted: Event<string>;
+    /**
+     * A collection of worlds managed by this component.
+     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
+     */
+    list: Map<string, World>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
+     *
+     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
+     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
+     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
+     *
+     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
+     */
+    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
+    /**
+     * Deletes a world from the list of worlds.
+     *
+     * @param {World} world - The world to be deleted.
+     *
+     * @throws {Error} - Throws an error if the provided world is not found in the list.
+     *
+     * @returns {void}
+     */
+    delete(world: World): void;
+    /**
+     * Disposes of the Worlds component and all its managed worlds.
+     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
+     * and triggers the onDisposed event.
+     *
+     * @returns {void}
+     */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(delta?: number): void | Promise<void>;
+}
+import { Components } from "../Components";
+import { MeshCullerRenderer, CullerRendererSettings } from "./src";
+import { Component, Event, Disposable, World } from "../Types";
+/**
+ * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
+ */
+export declare class Cullers extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
+    /**
+     * An event that is triggered when the Cullers component is disposed.
+     */
+    readonly onDisposed: Event<unknown>;
+    private _enabled;
+    /**
+     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
+     */
+    list: Map<string, MeshCullerRenderer>;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(value: boolean);
+    constructor(components: Components);
+    /**
+     * Creates a new MeshCullerRenderer for the given world.
+     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
+     *
+     * @param world - The world for which to create the MeshCullerRenderer.
+     * @param config - Optional configuration settings for the MeshCullerRenderer.
+     *
+     * @returns The newly created or existing MeshCullerRenderer for the given world.
+     */
+    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
+    /**
+     * Deletes the MeshCullerRenderer associated with the given world.
+     * If a MeshCullerRenderer exists for the given world, it will be disposed and removed from the list.
+     *
+     * @param world - The world for which to delete the MeshCullerRenderer.
+     *
+     * @returns {void}
+     */
+    delete(world: World): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
+import * as THREE from "three";
 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).
+ * Represents an edge measurement result.
  */
-export declare class IfcJsonExporter extends Component {
+export interface MeasureEdge {
+    /**
+     * The distance between the two points of the edge.
+     */
+    distance: number;
+    /**
+     * The two points that define the edge.
+     */
+    points: THREE.Vector3[];
+}
+/**
+ * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
+ */
+export declare class MeasurementUtils extends Component {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    static uuid: string;
     /** {@link Component.enabled} */
     enabled: boolean;
     constructor(components: Components);
     /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
+     * Utility method to calculate the distance from a point to a line segment.
+     *
+     * @param point - The point from which to calculate the distance.
+     * @param lineStart - The start point of the line segment.
+     * @param lineEnd - The end point of the line segment.
+     * @param clamp - If true, the distance will be clamped to the line segment's length.
+     * @returns The distance from the point to the line segment.
      */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    /**
+     * Method to get the face of a mesh that contains a given triangle index.
+     * It also returns the edges of the found face and their indices.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param triangleIndex - The index of the triangle within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
+     */
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    /**
+     * Method to get the vertices and normal of a mesh face at a given index.
+     * It also applies instance transformation if provided.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param faceIndex - The index of the face within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the vertices and normal of the face.
+     * @throws Will throw an error if the geometry is not indexed.
+     */
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    /**
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
+     *
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
+     */
+    round(vector: THREE.Vector3): void;
+    private getFaceData;
 }
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
@@ -1045,299 +1377,169 @@ export declare class BoundingBoxer extends Component implements Disposable {
     addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
     private static getFragmentBounds;
 }
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Disposable, Event, Components } from "../../core";
-/**
- * Types for boolean properties in IFC schema.
- */
-export type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
-/**
- * Types for string properties in IFC schema.
- */
-export type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
-/**
- * Types for numeric properties in IFC schema.
- */
-export type NumericPropTypes = "IfcInteger" | "IfcReal";
-/**
- * Interface representing a map of changed entities in a model. The keys are model UUIDs, and the values are sets of express IDs of changed entities.
- */
-export interface ChangeMap {
-    [modelID: string]: Set<number>;
-}
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Disposable, Component, Event, Components } from "../../core";
 /**
- * Interface representing a map of attribute listeners. The keys are model UUIDs, and the values are objects with express IDs as keys, and objects with attribute names as keys, and Event objects as values.
+ * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs to their respective express IDs.
  */
-export interface AttributeListener {
-    [modelID: string]: {
-        [expressID: number]: {
-            [attributeName: string]: Event<String | Boolean | Number>;
-        };
+export interface Classification {
+    /**
+     * A system within the classification.
+     * The key is the system name, and the value is an object representing the classes within the system.
+     */
+    [system: string]: {
+        /**
+         * A class within the system.
+         * The key is the class name, and the value is a map of fragment IDs to their respective express IDs.
+         */
+        [className: string]: FRAGS.FragmentIdMap;
     };
 }
 /**
- * Component to manage and edit properties and Psets in IFC files.
+ * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
  */
-export declare class IfcPropertiesManager extends Component implements Disposable {
+export declare class Classifier extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Event triggered when a file is requested for export.
-     */
-    readonly onRequestFile: Event<unknown>;
-    /**
-     * ArrayBuffer containing the IFC data to be exported.
-     */
-    ifcToExport: ArrayBuffer | null;
-    /**
-     * Event triggered when an element is added to a Pset.
-     */
-    readonly onElementToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        elementID: number;
-    }>;
-    /**
-     * Event triggered when a property is added to a Pset.
-     */
-    readonly onPropToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        propID: number;
-    }>;
-    /**
-     * Event triggered when a Pset is removed.
-     */
-    readonly onPsetRemoved: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-    }>;
-    /**
-     * Event triggered when data in the model changes.
-     */
-    readonly onDataChanged: Event<{
-        model: FragmentsGroup;
-        expressID: number;
-    }>;
-    /**
-     * Configuration for the WebAssembly module.
-     */
-    wasm: {
-        path: string;
-        absolute: boolean;
-    };
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
     /** {@link Component.enabled} */
     enabled: boolean;
     /**
-     * Map of attribute listeners.
-     */
-    attributeListeners: AttributeListener;
-    /**
-     * The currently selected model.
-     */
-    selectedModel?: FragmentsGroup;
-    /**
-     * Map of changed entities in the model.
+     * A map representing the classification systems.
+     * The key is the system name, and the value is an object representing the classes within the system.
      */
-    changeMap: ChangeMap;
+    list: Classification;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     constructor(components: Components);
+    private onFragmentsDisposed;
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
-     * Static method to retrieve the IFC schema from a given model.
+     * Removes a fragment from the classification based on its unique identifier (guid).
+     * This method iterates through all classification systems and classes, and deletes the fragment with the specified guid from the respective group.
      *
-     * @param model - The FragmentsGroup model from which to retrieve the IFC schema.
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @returns The IFC schema associated with the given model.
+     * @param guid - The unique identifier of the fragment to be removed.
      */
-    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
+    remove(guid: string): void;
     /**
-     * Method to set properties data in the model.
+     * Finds and returns fragments based on the provided filter criteria.
+     * If no filter is provided, it returns all fragments.
      *
-     * @param model - The FragmentsGroup model in which to set the properties.
-     * @param dataToSave - An array of objects representing the properties to be saved.
-     * Each object must have an 'expressID' property, which is the express ID of the entity in the model.
-     * The rest of the properties will be set as the properties of the entity.
+     * @param filter - An optional object containing filter criteria.
+     * The keys of the object represent the classification system names,
+     * and the values are arrays of class names to match.
      *
-     * @returns {Promise<void>} A promise that resolves when all the properties have been set.
+     * @returns A map of fragment GUIDs to their respective express IDs,
+     * where the express IDs are filtered based on the provided filter criteria.
      *
-     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'dataToSave' array.
+     * @throws Will throw an error if the fragments map is malformed.
      */
-    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
+    find(filter?: {
+        [name: string]: string[];
+    }): FRAGS.FragmentIdMap;
     /**
-     * Creates a new Property Set (Pset) in the given model.
+     * Classifies fragments based on their modelID.
      *
-     * @param model - The FragmentsGroup model in which to create the Pset.
-     * @param name - The name of the Pset.
-     * @param description - (Optional) The description of the Pset.
+     * @param modelID - The unique identifier of the model to classify fragments by.
+     * @param group - The FragmentsGroup containing the fragments to be classified.
      *
-     * @returns A promise that resolves with an object containing the newly created Pset and its relation.
+     * @remarks
+     * This method iterates through the fragments in the provided group,
+     * and classifies them based on their modelID.
+     * The classification is stored in the 'list.models' property,
+     * with the modelID as the key and a map of fragment IDs to their respective express IDs as the value.
      *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
-        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
-        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
-    }>;
+    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
     /**
-     * Removes a Property Set (Pset) from the given model.
+     * Classifies fragments based on their PredefinedType property.
      *
-     * @param model - The FragmentsGroup model from which to remove the Pset.
-     * @param psetID - The express IDs of the Psets to be removed.
+     * @param group - The FragmentsGroup containing the fragments to be classified.
      *
-     * @returns {Promise<void>} A promise that resolves when all the Psets have been removed.
+     * @remarks
+     * This method iterates through the properties of the fragments in the provided group,
+     * and classifies them based on their PredefinedType property.
+     * The classification is stored in the 'list.predefinedTypes' property,
+     * with the PredefinedType as the key and a map of fragment IDs to their respective express IDs as the value.
      *
-     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'psetID' array.
-     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
-     * @throws Will throw an error if no relation is found between the Pset and the model.
+     * @throws Will throw an error if the fragment ID is not found.
      */
-    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
+    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
     /**
-     * Creates a new single-value property of type string in the given model.
+     * Classifies fragments based on their entity type.
      *
-     * @param model - The FragmentsGroup model in which to create the property.
-     * @param type - The type of the property value. Must be a string property type.
-     * @param name - The name of the property.
-     * @param value - The value of the property. Must be a string.
+     * @param group - The FragmentsGroup containing the fragments to be classified.
      *
-     * @returns The newly created single-value property.
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their entity type.
+     * The classification is stored in the 'list.entities' property,
+     * with the entity type as the key and a map of fragment IDs to their respective express IDs as the value.
      *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * @throws Will throw an error if the fragment ID is not found.
      */
-    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    byEntity(group: FRAGS.FragmentsGroup): void;
     /**
-     * Creates a new single-value property of type numeric in the given model.
+     * Classifies fragments based on a specific IFC relationship.
      *
-     * @param model - The FragmentsGroup model in which to create the property.
-     * @param type - The type of the property value. Must be a numeric property type.
-     * @param name - The name of the property.
-     * @param value - The value of the property. Must be a number.
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     * @param ifcRel - The IFC relationship number to classify fragments by.
+     * @param systemName - The name of the classification system to store the classification.
      *
-     * @returns The newly created single-value property.
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on the specified IFC relationship.
+     * The classification is stored in the 'list' property under the specified system name,
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
      *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
      */
-    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
     /**
-     * Creates a new single-value property of type boolean in the given model.
+     * Classifies fragments based on their spatial structure in the IFC model.
      *
-     * @param model - The FragmentsGroup model in which to create the property.
-     * @param type - The type of the property value. Must be a boolean property type.
-     * @param name - The name of the property.
-     * @param value - The value of the property. Must be a boolean.
+     * @param model - The FragmentsGroup containing the fragments to be classified.
      *
-     * @returns The newly created single-value property.
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their spatial structure in the IFC model.
+     * The classification is stored in the 'list' property under the system name "spatialStructures",
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
      *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
      */
-    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
     /**
-     * Removes a property from a Property Set (Pset) in the given model.
+     * Sets the color of the specified fragments.
      *
-     * @param model - The FragmentsGroup model from which to remove the property.
-     * @param psetID - The express ID of the Pset from which to remove the property.
-     * @param propID - The express ID of the property to be removed.
+     * @param items - A map of fragment IDs to their respective express IDs.
+     * @param color - The color to set for the fragments.
+     * @param override - A boolean indicating whether to override the existing color of the fragments.
      *
-     * @returns {Promise<void>} A promise that resolves when the property has been removed.
+     * @remarks
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and sets their color using the 'setColor' method of the FragmentsGroup class.
      *
-     * @throws Will throw an error if the Pset or the property to be removed are not found in the model.
-     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
+     * @throws Will throw an error if the fragment with the specified ID is not found.
      */
-    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
-    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
+    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
     /**
-     * Adds elements to a Property Set (Pset) in the given model.
+     * Resets the color of the specified fragments to their original color.
      *
-     * @param model - The FragmentsGroup model in which to add the elements.
-     * @param psetID - The express ID of the Pset to which to add the elements.
-     * @param elementID - The express IDs of the elements to be added.
+     * @param items - A map of fragment IDs to their respective express IDs.
      *
-     * @returns {Promise<void>} A promise that resolves when all the elements have been added.
+     * @remarks
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and resets their color using the 'resetColor' method of the FragmentsGroup class.
      *
-     * @throws Will throw an error if the Pset or the elements to be added are not found in the model.
-     * @throws Will throw an error if the Pset to be added to is not of type 'IFCPROPERTYSET'.
-     * @throws Will throw an error if no relation is found between the Pset and the model.
-     */
-    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
-    /**
-     * Saves the changes made to the model to a new IFC file.
-     *
-     * @param model - The FragmentsGroup model from which to save the changes.
-     * @param ifcToSaveOn - The Uint8Array representing the original IFC file.
-     *
-     * @returns A promise that resolves with the modified IFC data as a Uint8Array.
-     *
-     * @throws Will throw an error if any issues occur during the saving process.
-     */
-    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
-    /**
-     * 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.
-     *
-     * @param model - The FragmentsGroup model in which to set the attribute listener.
-     * @param expressID - The express ID of the entity for which to set the listener.
-     * @param attributeName - The name of the attribute for which to set the listener.
-     *
-     * @returns The event that will be triggered when the attribute's value changes.
-     *
-     * @throws Will throw an error if the entity with the given expressID doesn't exist.
-     * @throws Will throw an error if the attribute is an array or null, and it can't have a listener.
-     * @throws Will throw an error if the attribute has a badly defined handle.
-     */
-    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
-    private increaseMaxID;
-    private newGUID;
-    private getOwnerHistory;
-    private registerChange;
-    private newSingleProperty;
-}
-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}
+     * @throws Will throw an error if the fragment with the specified ID is not found.
      */
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
+    resetColor(items: FRAGS.FragmentIdMap): void;
+    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
 }
 import { Component, Disposable, Event, Components } from "../../core";
 /**
@@ -1389,169 +1591,43 @@ export declare class Exploder extends Component implements Disposable {
      */
     set(active: boolean): void;
 }
-import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
-import { Disposable, Component, Event, Components } from "../../core";
-/**
- * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs to their respective express IDs.
- */
-export interface Classification {
-    /**
-     * A system within the classification.
-     * The key is the system name, and the value is an object representing the classes within the system.
-     */
-    [system: string]: {
-        /**
-         * A class within the system.
-         * The key is the class name, and the value is a map of fragment IDs to their respective express IDs.
-         */
-        [className: string]: FRAGS.FragmentIdMap;
-    };
-}
+import { Components, Component } from "../../core";
 /**
- * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
+ * A 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 Classifier extends Component implements Disposable {
+export declare class Hider extends Component {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
     /** {@link Component.enabled} */
     enabled: boolean;
-    /**
-     * A map representing the classification systems.
-     * The key is the system name, and the value is an object representing the classes within the system.
-     */
-    list: Classification;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
     constructor(components: Components);
-    private onFragmentsDisposed;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Removes a fragment from the classification based on its unique identifier (guid).
-     * This method iterates through all classification systems and classes, and deletes the fragment with the specified guid from the respective group.
-     *
-     * @param guid - The unique identifier of the fragment to be removed.
-     */
-    remove(guid: string): void;
-    /**
-     * Finds and returns fragments based on the provided filter criteria.
-     * If no filter is provided, it returns all fragments.
-     *
-     * @param filter - An optional object containing filter criteria.
-     * The keys of the object represent the classification system names,
-     * and the values are arrays of class names to match.
-     *
-     * @returns A map of fragment GUIDs to their respective express IDs,
-     * where the express IDs are filtered based on the provided filter criteria.
-     *
-     * @throws Will throw an error if the fragments map is malformed.
-     */
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
-    /**
-     * Classifies fragments based on their modelID.
-     *
-     * @param modelID - The unique identifier of the model to classify fragments by.
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the fragments in the provided group,
-     * and classifies them based on their modelID.
-     * The classification is stored in the 'list.models' property,
-     * with the modelID as the key and a map of fragment IDs to their respective express IDs as the value.
-     *
-     */
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
-    /**
-     * Classifies fragments based on their PredefinedType property.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the properties of the fragments in the provided group,
-     * and classifies them based on their PredefinedType property.
-     * The classification is stored in the 'list.predefinedTypes' property,
-     * with the PredefinedType as the key and a map of fragment IDs to their respective express IDs as the value.
-     *
-     * @throws Will throw an error if the fragment ID is not found.
-     */
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
-    /**
-     * Classifies fragments based on their entity type.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on their entity type.
-     * The classification is stored in the 'list.entities' property,
-     * with the entity type as the key and a map of fragment IDs to their respective express IDs as the value.
-     *
-     * @throws Will throw an error if the fragment ID is not found.
-     */
-    byEntity(group: FRAGS.FragmentsGroup): void;
-    /**
-     * Classifies fragments based on a specific IFC relationship.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     * @param ifcRel - The IFC relationship number to classify fragments by.
-     * @param systemName - The name of the classification system to store the classification.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on the specified IFC relationship.
-     * The classification is stored in the 'list' property under the specified system name,
-     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
-     *
-     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
-     */
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
     /**
-     * Classifies fragments based on their spatial structure in the IFC model.
-     *
-     * @param model - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on their spatial structure in the IFC model.
-     * The classification is stored in the 'list' property under the system name "spatialStructures",
-     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
-     *
-     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
-     */
-    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
-    /**
-     * Sets the color of the specified fragments.
-     *
-     * @param items - A map of fragment IDs to their respective express IDs.
-     * @param color - The color to set for the fragments.
-     * @param override - A boolean indicating whether to override the existing color of the fragments.
+     * Sets the visibility of fragments within the 3D scene.
+     * If no 'items' parameter is provided, all fragments will be set to the specified visibility.
+     * If 'items' is provided, only the specified fragments will be affected.
      *
-     * @remarks
-     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
-     * and sets their color using the 'setColor' method of the FragmentsGroup class.
+     * @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.
      *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
+     * @returns {void}
      */
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
     /**
-     * Resets the color of the specified fragments to their original color.
-     *
-     * @param items - A map of fragment IDs to their respective express IDs.
+     * 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.
      *
-     * @remarks
-     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
-     * and resets their color using the 'resetColor' method of the FragmentsGroup class.
+     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
+     * If not provided, all fragments will be isolated.
      *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
+     * @returns {void}
      */
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
 }
 import * as WEBIFC from "web-ifc";
 import * as FRAGS from "@thatopen/fragments";
@@ -1780,147 +1856,55 @@ export declare class FragmentsManager extends Component implements Disposable {
      */
     coordinate(models?: FragmentsGroup[]): void;
 }
-import * as THREE from "three";
-import { Component, Components } from "../../core";
 /**
- * Represents an edge measurement result.
+ * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
+ *
+ * @remarks
+ * This map is used to provide a mapping between IFC entity type numbers and their names.
+ * It is useful for identifying and processing different types of IFC elements in a project.
+ *
  */
-export interface MeasureEdge {
-    /**
-     * The distance between the two points of the edge.
-     */
-    distance: number;
-    /**
-     * The two points that define the edge.
-     */
-    points: THREE.Vector3[];
-}
-/**
- * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
- */
-export declare class MeasurementUtils extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Utility method to calculate the distance from a point to a line segment.
-     *
-     * @param point - The point from which to calculate the distance.
-     * @param lineStart - The start point of the line segment.
-     * @param lineEnd - The end point of the line segment.
-     * @param clamp - If true, the distance will be clamped to the line segment's length.
-     * @returns The distance from the point to the line segment.
-     */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    /**
-     * Method to get the face of a mesh that contains a given triangle index.
-     * It also returns the edges of the found face and their indices.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param triangleIndex - The index of the triangle within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
-     */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
-     */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
-     *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
-     */
-    round(vector: THREE.Vector3): void;
-    private getFaceData;
+export declare const IfcElements: {
+    [key: number]: string;
+};
+import * as FRAGS from "@thatopen/fragments";
+export declare class IfcPropertiesUtils {
+    static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
+    static findItemByGuid(model: FRAGS.FragmentsGroup, guid: string): Promise<{
+        [attribute: string]: any;
+    } | null>;
+    static getRelationMap(model: FRAGS.FragmentsGroup, relationType: number, onElementsFound?: (relatingID: number, relatedIDs: number[]) => Promise<void>): Promise<{
+        [relatingID: number]: number[];
+    }>;
+    static getQsetQuantities(model: FRAGS.FragmentsGroup, expressID: number, onQuantityFound?: (expressID: number) => void): Promise<number[] | null>;
+    static getPsetProps(model: FRAGS.FragmentsGroup, expressID: number, onPropFound?: (expressID: number) => void): Promise<number[] | null>;
+    static getPsetRel(model: FRAGS.FragmentsGroup, psetID: number): Promise<number | null>;
+    static getQsetRel(model: FRAGS.FragmentsGroup, qsetID: number): Promise<number | null>;
+    static getEntityName(model: FRAGS.FragmentsGroup, entityID: number): Promise<{
+        key: string | null;
+        name: string | null;
+    }>;
+    static getQuantityValue(model: FRAGS.FragmentsGroup, quantityID: number): Promise<{
+        key: string | null;
+        value: number | null;
+    }>;
+    static isRel(expressID: number): boolean;
+    static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
+    static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
 }
 import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../core";
-import { PropertiesStreamingSettings } from "./src";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
+}
 /**
- * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
+ * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
  */
-export declare class IfcPropertiesTiler extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
-    /**
-     * An event that is triggered when properties are streamed from the IFC file.
-     * The event provides the type of the IFC entity and the corresponding data.
-     */
-    readonly onPropertiesStreamed: AsyncEvent<{
-        type: number;
-        data: {
-            [id: number]: any;
-        };
-    }>;
-    /**
-     * An event that is triggered to indicate the progress of the streaming process.
-     * The event provides a number between 0 and 1 representing the progress percentage.
-     */
-    readonly onProgress: AsyncEvent<number>;
-    /**
-     * An event that is triggered when indices are streamed from the IFC file.
-     * The event provides a map of indices, where the key is the entity type and the value is another map of indices.
-     */
-    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
-     */
-    settings: PropertiesStreamingSettings;
-    /**
-     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
-     */
-    webIfc: WEBIFC.IfcAPI;
-    /** {@link Disposable.dispose} */
-    dispose(): Promise<void>;
-    /**
-     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
-     *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @returns A Promise that resolves when the streaming process is complete.
-     */
-    streamFromBuffer(data: Uint8Array): Promise<void>;
-    /**
-     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
-     *
-     * @param loadCallback - A callback function that loads the IFC file data.
-     * @returns A Promise that resolves when the streaming process is complete.
-     */
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllProperties;
-    private cleanUp;
-}
+export declare const IfcCategoryMap: {
+    [key: number]: string;
+};
 import * as WEBIFC from "web-ifc";
 import { Components, Disposable, Event, Component } from "../../core";
 import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
@@ -2020,192 +2004,584 @@ export declare class IfcGeometryTiler extends Component implements Disposable {
     private streamGeometries;
 }
 import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}
+import { AsyncEvent, Component, Disposable, Event } from "../../core";
+import { PropertiesStreamingSettings } from "./src";
 /**
- * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
- *
- * @remarks
- * This map is used to provide a mapping between IFC entity type numbers and their names.
- * It is useful for identifying and processing different types of IFC elements in a project.
- *
+ * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
  */
-export declare const IfcElements: {
-    [key: number]: string;
-};
-import * as FRAGS from "@thatopen/fragments";
-export declare class IfcPropertiesUtils {
-    static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
-    static findItemByGuid(model: FRAGS.FragmentsGroup, guid: string): Promise<{
-        [attribute: string]: any;
-    } | null>;
-    static getRelationMap(model: FRAGS.FragmentsGroup, relationType: number, onElementsFound?: (relatingID: number, relatedIDs: number[]) => Promise<void>): Promise<{
-        [relatingID: number]: number[];
-    }>;
-    static getQsetQuantities(model: FRAGS.FragmentsGroup, expressID: number, onQuantityFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetProps(model: FRAGS.FragmentsGroup, expressID: number, onPropFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetRel(model: FRAGS.FragmentsGroup, psetID: number): Promise<number | null>;
-    static getQsetRel(model: FRAGS.FragmentsGroup, qsetID: number): Promise<number | null>;
-    static getEntityName(model: FRAGS.FragmentsGroup, entityID: number): Promise<{
-        key: string | null;
-        name: string | null;
-    }>;
-    static getQuantityValue(model: FRAGS.FragmentsGroup, quantityID: number): Promise<{
-        key: string | null;
-        value: number | null;
+export declare class IfcPropertiesTiler extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    /**
+     * An event that is triggered when properties are streamed from the IFC file.
+     * The event provides the type of the IFC entity and the corresponding data.
+     */
+    readonly onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
+        };
     }>;
-    static isRel(expressID: number): boolean;
-    static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
-    static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
-}
-/**
- * A Set of unique numbers representing different types of IFC geometries.
- */
-export declare const GeometryTypes: Set<number>;
-/**
- * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
- */
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
-import * as THREE from "three";
-import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
-/**
- * A class representing a 2D minimap of a 3D world.
- */
-export declare class MiniMap implements Resizeable, Updateable, Disposable {
+    /**
+     * An event that is triggered to indicate the progress of the streaming process.
+     * The event provides a number between 0 and 1 representing the progress percentage.
+     */
+    readonly onProgress: AsyncEvent<number>;
+    /**
+     * An event that is triggered when indices are streamed from the IFC file.
+     * The event provides a map of indices, where the key is the entity type and the value is another map of indices.
+     */
+    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
+    readonly onDisposed: Event<string>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * The front offset of the minimap.
+     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
+     */
+    settings: PropertiesStreamingSettings;
+    /**
+     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
+     */
+    webIfc: WEBIFC.IfcAPI;
+    /** {@link Disposable.dispose} */
+    dispose(): Promise<void>;
+    /**
+     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
+     */
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    /**
+     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
+     *
+     * @param loadCallback - A callback function that loads the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
+     */
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private cleanUp;
+}
+/**
+ * A Set of unique numbers representing different types of IFC geometries.
+ */
+export declare const GeometryTypes: Set<number>;
+import { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<number, {
+    forRelating: InverseAttribute;
+    forRelated: InverseAttribute;
+}>;
+import * as THREE from "three";
+import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
+/**
+ * A class representing a 2D minimap of a 3D world.
+ */
+export declare class MiniMap implements Resizeable, Updateable, Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Resizeable.onResize} */
+    readonly onResize: Event<THREE.Vector2>;
+    /**
+     * The front offset of the minimap.
      * It determines how much the minimap's view is offset from the camera's view.
      * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
      */
-    frontOffset: number;
+    frontOffset: number;
+    /**
+     * The override material for the minimap.
+     * It is used to render the depth information of the world onto the minimap.
+     */
+    overrideMaterial: THREE.MeshDepthMaterial;
+    /**
+     * The background color of the minimap.
+     * It is used to set the background color of the minimap's renderer.
+     */
+    backgroundColor: THREE.Color;
+    /**
+     * The WebGL renderer for the minimap.
+     * It is used to render the minimap onto the screen.
+     */
+    renderer: THREE.WebGLRenderer;
+    /**
+     * A flag indicating whether the minimap is enabled.
+     * If disabled, the minimap will not update or render.
+     */
+    enabled: boolean;
+    /**
+     * The world in which the minimap is displayed.
+     * It provides access to the 3D scene, camera, and other relevant world elements.
+     */
+    world: World;
+    private _lockRotation;
+    private _camera;
+    private _plane;
+    private _size;
+    private _tempVector1;
+    private _tempVector2;
+    private _tempTarget;
+    private readonly down;
+    /**
+     * Gets or sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
+     */
+    get lockRotation(): boolean;
+    /**
+     * Sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
+     * @param active - If 'true', rotation is locked. If 'false', rotation is not locked.
+     */
+    set lockRotation(active: boolean);
+    /**
+     * Gets the current zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @returns The current zoom level of the minimap.
+     */
+    get zoom(): number;
+    /**
+     * Sets the zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @param value - The new zoom level of the minimap.
+     */
+    set zoom(value: number);
+    constructor(world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** Returns the camera used by the MiniMap */
+    get(): THREE.OrthographicCamera;
+    /** {@link Updateable.update} */
+    update(): void;
+    /** {@link Resizeable.getSize} */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize(size?: THREE.Vector2): void;
+    private updatePlanes;
+}
+import * as WEBIFC from "web-ifc";
+/** Configuration of the IFC-fragment conversion. */
+export declare class IfcFragmentSettings {
+    /** Whether to extract the IFC properties into a JSON. */
+    includeProperties: boolean;
+    /**
+     * Generate the geometry for categories that are not included by default,
+     * like IFCSPACE.
+     */
+    optionalCategories: number[];
+    /** Whether to use the coordination data coming from the IFC files. */
+    coordinate: boolean;
+    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    wasm: {
+        path: string;
+        absolute: boolean;
+        logLevel?: WEBIFC.LogLevel;
+    };
+    /** List of categories that won't be converted to fragments. */
+    excludedCategories: Set<number>;
+    /** Whether to save the absolute location of all IFC items. */
+    saveLocations: boolean;
+    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    webIfc: WEBIFC.LoaderSettings;
+    /**
+     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * If set to true, the path will be set to the default path of the WASM file.
+     * If set to false, the path must be provided manually in the 'wasm.path' property.
+     * Default value is true.
+     */
+    autoSetWasm: boolean;
+    /**
+     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
+     * If set to null, the default file location handler will be used.
+     *
+     * @param url - The URL of the file to locate.
+     * @returns The absolute path of the file.
+     */
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+import * as THREE from "three";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+import { Mouse } from "./mouse";
+/**
+ * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
+ */
+export declare class SimpleRaycaster implements Disposable {
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /** The components instance to which this Raycaster belongs. */
+    components: Components;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** The position of the mouse in the screen. */
+    readonly mouse: Mouse;
+    /**
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
+     */
+    readonly three: THREE.Raycaster;
+    /**
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
+     */
+    world: World;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Throws a ray from the camera to the mouse or touch event point and returns
+     * the first item found. This also takes into account the clipping planes
+     * used by the renderer.
+     *
+     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
+     * to query. If not provided, it will query all the meshes stored in
+     * {@link Components.meshes}.
+     */
+    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    /**
+     * Casts a ray from a given origin in a given direction and returns the first item found.
+     * This method also takes into account the clipping planes used by the renderer.
+     *
+     * @param origin - The origin of the ray.
+     * @param direction - The direction of the ray.
+     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
+     * @returns The first intersection found or 'null' if no intersection was found.
+     */
+    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
+    private intersect;
+    private filterClippingPlanes;
+}
+import * as 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 { 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 * 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 { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+/**
+ * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
+ *
+ * @template T - The type of the scene. Default is BaseScene.
+ * @template U - The type of the camera. Default is BaseCamera.
+ * @template S - The type of the renderer. Default is BaseRenderer.
+ */
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
+    /**
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
+     */
+    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
+     */
+    isDisposing: boolean;
+    /**
+     * Indicates whether the world is currently enabled.
+     * When disabled, the world will not be updated.
+     */
+    enabled: boolean;
+    /**
+     * A unique identifier for the world.
+     */
+    uuid: string;
+    /**
+     * An optional name for the world.
+     */
+    name?: string;
+    private _scene?;
+    private _camera?;
+    private _renderer;
+    /**
+     * Getter for the scene. If no scene is initialized, it throws an error.
+     * @returns The current scene.
+     */
+    get scene(): T;
     /**
-     * The override material for the minimap.
-     * It is used to render the depth information of the world onto the minimap.
+     * 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.
      */
-    overrideMaterial: THREE.MeshDepthMaterial;
+    set scene(scene: T);
     /**
-     * The background color of the minimap.
-     * It is used to set the background color of the minimap's renderer.
+     * Getter for the camera. If no camera is initialized, it throws an error.
+     * @returns The current camera.
      */
-    backgroundColor: THREE.Color;
+    get camera(): U;
     /**
-     * The WebGL renderer for the minimap.
-     * It is used to render the minimap onto the screen.
+     * 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.
      */
-    renderer: THREE.WebGLRenderer;
+    set camera(camera: U);
     /**
-     * A flag indicating whether the minimap is enabled.
-     * If disabled, the minimap will not update or render.
+     * 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).
      */
-    enabled: boolean;
+    get renderer(): S | null;
     /**
-     * The world in which the minimap is displayed.
-     * It provides access to the 3D scene, camera, and other relevant world elements.
+     * 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.
      */
-    world: World;
-    private _lockRotation;
-    private _camera;
-    private _plane;
-    private _size;
-    private _tempVector1;
-    private _tempVector2;
-    private _tempTarget;
-    private readonly down;
+    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 { BaseRenderer, Event } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
+ */
+export declare class SimpleRenderer extends BaseRenderer {
     /**
-     * Gets or sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
+     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
+     * Default is 'true'.
      */
-    get lockRotation(): boolean;
+    enabled: boolean;
     /**
-     * Sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
-     * @param active - If 'true', rotation is locked. If 'false', rotation is not locked.
+     * The HTML container of the THREE.js canvas where the scene is rendered.
      */
-    set lockRotation(active: boolean);
+    container: HTMLElement;
     /**
-     * Gets the current zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @returns The current zoom level of the minimap.
+     * The THREE.js WebGLRenderer instance.
      */
-    get zoom(): number;
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<unknown>;
+    private _resizing;
     /**
-     * Sets the zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @param value - The new zoom level of the minimap.
+     * Constructor for the SimpleRenderer class.
+     *
+     * @param components - The components instance.
+     * @param container - The HTML container where the THREE.js canvas will be rendered.
+     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
      */
-    set zoom(value: number);
-    constructor(world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** Returns the camera used by the MiniMap */
-    get(): THREE.OrthographicCamera;
+    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
     /** {@link Updateable.update} */
     update(): void;
-    /** {@link Resizeable.getSize} */
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Resizeable.getSize}. */
     getSize(): THREE.Vector2;
     /** {@link Resizeable.resize} */
-    resize(size?: THREE.Vector2): void;
-    private updatePlanes;
-}
-import { InverseAttribute } from "./types";
-export declare const relToAttributesMap: Map<number, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;
-import * as WEBIFC from "web-ifc";
-/** Configuration of the IFC-fragment conversion. */
-export declare class IfcFragmentSettings {
-    /** Whether to extract the IFC properties into a JSON. */
-    includeProperties: boolean;
+    resize: (size?: THREE.Vector2) => void;
     /**
-     * Generate the geometry for categories that are not included by default,
-     * like IFCSPACE.
+     * 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.
      */
-    optionalCategories: number[];
-    /** Whether to use the coordination data coming from the IFC files. */
-    coordinate: boolean;
-    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    wasm: {
-        path: string;
-        absolute: boolean;
-        logLevel?: WEBIFC.LogLevel;
+    setupEvents(active: boolean): void;
+    private resizeEvent;
+    private setupRenderer;
+    private onContextLost;
+    private onContextBack;
+}
+import * as THREE from "three";
+import { BaseScene, Configurable, Event } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * 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;
     };
-    /** List of categories that won't be converted to fragments. */
-    excludedCategories: Set<number>;
-    /** Whether to save the absolute location of all IFC items. */
-    saveLocations: boolean;
-    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    webIfc: WEBIFC.LoaderSettings;
+    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;
     /**
-     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * If set to true, the path will be set to the default path of the WASM file.
-     * If set to false, the path must be provided manually in the 'wasm.path' property.
-     * Default value is true.
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
      */
-    autoSetWasm: boolean;
+    three: THREE.Scene;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<SimpleScene>;
     /**
-     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
-     * If set to null, the default file location handler will be used.
+     * Configuration interface for the {@link SimpleScene}.
+     * Defines properties for directional and ambient lights.
+     */
+    config: Required<SimpleSceneConfig>;
+    constructor(components: Components);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleSceneConfig>): void;
+}
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * 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 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>;
+    /**
+     * A three.js PerspectiveCamera or OrthographicCamera instance.
+     * This camera is used for rendering the scene.
+     */
+    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    private _allControls;
+    /**
+     * The object that controls the camera. An instance of
+     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
+     * Transforming the camera directly will have no effect: you need to use this
+     * object to move, rotate, look at objects, etc.
+     */
+    get controls(): CameraControls;
+    /**
+     * Getter for the enabled state of the camera controls.
+     * If the current world is null, it returns false.
+     * Otherwise, it returns the enabled state of the camera controls.
      *
-     * @param url - The URL of the file to locate.
-     * @returns The absolute path of the file.
+     * @returns {boolean} The enabled state of the camera controls.
      */
-    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+    get enabled(): boolean;
+    /**
+     * Setter for the enabled state of the camera controls.
+     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
+     *
+     * @param {boolean} enabled - The new enabled state of the camera controls.
+     */
+    set enabled(enabled: boolean);
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(_delta: number): void;
+    /**
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
+     */
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
 }
 /**
  * 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.
@@ -2371,14 +2747,6 @@ export interface CameraControllable {
      */
     controls: CameraControls;
 }
-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 { Base } from "./base";
 /**
  * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
@@ -2392,28 +2760,24 @@ export declare abstract class Component extends Base {
      */
     abstract enabled: boolean;
 }
-import { Base } from "./base";
-import { World } from "./world";
-import { Event } from "./event";
+import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
 import { Components } from "../../Components";
 /**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
+ * Base class of the library. Useful for finding out the interfaces something implements.
  */
-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);
+export declare abstract class Base {
+    components: Components;
+    constructor(components: Components);
+    /** Whether is component is {@link Disposable}. */
+    isDisposeable: () => this is Disposable;
+    /** Whether is component is {@link Resizeable}. */
+    isResizeable: () => this is Resizeable;
+    /** Whether is component is {@link Updateable}. */
+    isUpdateable: () => this is Updateable;
+    /** Whether is component is {@link Hideable}. */
+    isHideable: () => this is Hideable;
+    /** Whether is component is {@link Configurable}. */
+    isConfigurable: () => this is Configurable<any>;
 }
 import * as THREE from "three";
 import CameraControls from "camera-controls";
@@ -2443,58 +2807,48 @@ export declare abstract class BaseCamera extends BaseWorldItem {
      */
     hasCameraControls: () => this is CameraControllable;
 }
-import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
+import { Base } from "./base";
+import { World } from "./world";
+import { Event } from "./event";
 import { Components } from "../../Components";
 /**
- * Base class of the library. Useful for finding out the interfaces something implements.
- */
-export declare abstract class Base {
-    components: Components;
-    constructor(components: Components);
-    /** Whether is component is {@link Disposable}. */
-    isDisposeable: () => this is Disposable;
-    /** Whether is component is {@link Resizeable}. */
-    isResizeable: () => this is Resizeable;
-    /** Whether is component is {@link Updateable}. */
-    isUpdateable: () => this is Updateable;
-    /** Whether is component is {@link Hideable}. */
-    isHideable: () => this is Hideable;
-    /** Whether is component is {@link Configurable}. */
-    isConfigurable: () => this is Configurable<any>;
-}
-import * 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.
+ * One of the elements that make a world. It can be either a scene, a camera or a renderer.
  */
-export interface World extends Disposable, Updateable {
-    /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
-     */
-    meshes: Set<THREE.Mesh>;
-    /**
-     * The base scene of the world.
-     */
-    scene: BaseScene;
-    /**
-     * The base camera of the world.
-     */
-    camera: BaseCamera;
+export declare abstract class BaseWorldItem extends Base {
+    readonly worlds: Map<string, World>;
     /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
+     * 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").
      */
-    renderer: BaseRenderer | null;
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
+    }>;
     /**
-     * A unique identifier for the world.
+     * The current world this item is associated with. It can be null if no world is currently active.
      */
-    uuid: string;
+    currentWorld: World | null;
+    protected constructor(components: Components);
+}
+import * as THREE from "three";
+import { Disposable } from "./interfaces";
+import { Event } from "./event";
+import { Components } from "../../Components";
+import { BaseWorldItem } from "./base-world-item";
+/**
+ * Abstract class representing a base scene in the application. All scenes should use this class as a base.
+ */
+export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     * Abstract property representing the three.js object associated with this scene.
+     * It should be implemented by subclasses.
      */
-    isDisposing: boolean;
+    abstract three: THREE.Object3D;
+    protected constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
 }
 import * as THREE from "three";
 import { Vector2 } from "three";
@@ -2562,196 +2916,94 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
     setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }
 import * as THREE from "three";
-import { Disposable } from "./interfaces";
-import { Event } from "./event";
-import { Components } from "../../Components";
-import { BaseWorldItem } from "./base-world-item";
+import { BaseScene } from "./base-scene";
+import { BaseCamera } from "./base-camera";
+import { BaseRenderer } from "./base-renderer";
+import { Updateable, Disposable } from "./interfaces";
 /**
- * Abstract class representing a base scene in the application. All scenes should use this class as a base.
+ * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
  */
-export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+export interface World extends Disposable, Updateable {
     /**
-     * Abstract property representing the three.js object associated with this scene.
-     * It should be implemented by subclasses.
+     * A set of meshes present in the world. This is taken into account for operations like raycasting.
      */
-    abstract three: THREE.Object3D;
-    protected constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}
-import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
-/**
- * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
- *
- * @template T - The type of the scene. Default is BaseScene.
- * @template U - The type of the camera. Default is BaseCamera.
- * @template S - The type of the renderer. Default is BaseRenderer.
- */
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
+    meshes: Set<THREE.Mesh>;
     /**
-     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
+     * The base scene of the world.
      */
-    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>;
+    scene: BaseScene;
     /**
-     * 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.
+     * The base camera of the world.
      */
-    isDisposing: boolean;
+    camera: BaseCamera;
     /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
+     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
      */
-    enabled: boolean;
+    renderer: BaseRenderer | null;
     /**
      * A unique identifier for the world.
      */
     uuid: string;
     /**
-     * An optional name for the world.
-     */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
-    /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
-     */
-    get scene(): T;
-    /**
-     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
-     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
-     * @param scene - The new scene to be set.
-     */
-    set scene(scene: T);
-    /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
-     */
-    get camera(): U;
-    /**
-     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
-     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
-     * @param camera - The new camera to be set.
-     */
-    set camera(camera: U);
-    /**
-     * Getter for the renderer.
-     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
-     */
-    get renderer(): S | null;
-    /**
-     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
-     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
-     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
-     * @param renderer - The new renderer to be set or null to remove the current renderer.
-     */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
-    /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
-}
-import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
-import { Components } from "../../Components";
-/**
- * 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.
- */
-export declare class SimpleScene extends BaseScene implements Configurable<{}> {
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /**
-     * The underlying Three.js scene object.
-     * It is used to define the 3D space containing objects, lights, and cameras.
-     */
-    three: THREE.Scene;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<SimpleScene>;
-    /**
-     * Configuration interface for the {@link SimpleScene}.
-     * Defines properties for directional and ambient lights.
+     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
      */
-    config: Required<SimpleSceneConfig>;
-    constructor(components: Components);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): void;
+    isDisposing: boolean;
 }
 import * as THREE from "three";
-import { BaseRenderer, Event } from "../../Types";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
 import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
 /**
- * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
  */
-export declare class SimpleRenderer extends BaseRenderer {
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
-     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
-     * Default is 'true'.
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
      */
-    enabled: boolean;
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
     /**
-     * The HTML container of the THREE.js canvas where the scene is rendered.
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
      */
-    container: HTMLElement;
+    threshold: number;
     /**
-     * The THREE.js WebGLRenderer instance.
+     * Map of color code to THREE.InstancedMesh.
+     * Used to keep track of color-coded meshes.
      */
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /**
-     * 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.
+     * Flag to indicate if the renderer is currently processing.
+     * Used to prevent concurrent processing.
      */
-    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
-    /** {@link Updateable.update} */
-    update(): void;
+    isProcessing: boolean;
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private _intervalID;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@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.
+     * 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}
      */
-    setupEvents(active: boolean): void;
-    private resizeEvent;
-    private setupRenderer;
-    private onContextLost;
-    private onContextBack;
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    /**
+     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
+     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
+     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
+     */
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
 }
 import * as THREE from "three";
 import { Components } from "../../Components";
@@ -2845,206 +3097,103 @@ export declare class CullerRenderer {
     private applySettings;
 }
 import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
+import { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
 /**
- * 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.
+ * Each of the clipping planes created by the clipper.
  */
-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>;
+export declare class SimplePlane implements Disposable, Hideable {
+    /** Event that fires when the user starts dragging a clipping plane. */
+    readonly onDraggingStarted: Event<unknown>;
+    /** Event that fires when the user stops dragging a clipping plane. */
+    readonly onDraggingEnded: Event<unknown>;
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * A three.js PerspectiveCamera or OrthographicCamera instance.
-     * This camera is used for rendering the scene.
-     */
-    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    private _allControls;
-    /**
-     * The object that controls the camera. An instance of
-     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
-     * Transforming the camera directly will have no effect: you need to use this
-     * object to move, rotate, look at objects, etc.
-     */
-    get controls(): CameraControls;
-    /**
-     * Getter for the enabled state of the camera controls.
-     * If the current world is null, it returns false.
-     * Otherwise, it returns the enabled state of the camera controls.
-     *
-     * @returns {boolean} The enabled state of the camera controls.
-     */
-    get enabled(): boolean;
-    /**
-     * Setter for the enabled state of the camera controls.
-     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
-     *
-     * @param {boolean} enabled - The new enabled state of the camera controls.
-     */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
-    /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
-     */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
-}
-import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-/**
- * A renderer to hide/show meshes depending on their visibility from the user's point of view.
- */
-export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
-    /**
-     * Event triggered when the visibility of meshes is updated.
-     * Contains two sets: seen and unseen.
-     */
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
-    }>;
-    /**
-     * Pixels in screen a geometry must occupy to be considered "seen".
-     * Default value is 100.
-     */
-    threshold: number;
-    /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
-     */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    /**
-     * Flag to indicate if the renderer is currently processing.
-     * Used to prevent concurrent processing.
-     */
-    isProcessing: boolean;
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private _intervalID;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
-     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
-     */
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    readonly onDisposed: Event<unknown>;
     /**
-     * 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}
+     * The normal vector of the clipping plane.
      */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
-}
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
-import * as THREE from "three";
-import { Hideable, Event, World, Disposable } from "../../Types";
-import { Components } from "../../Components";
-/**
- * Configuration interface for the {@link SimpleGrid} class.
- */
-export interface GridConfig {
+    readonly normal: THREE.Vector3;
     /**
-     * The color of the grid lines.
+     * The origin point of the clipping plane.
      */
-    color: THREE.Color;
+    readonly origin: THREE.Vector3;
     /**
-     * The size of the primary grid lines.
+     * The THREE.js Plane object representing the clipping plane.
      */
-    size1: number;
+    readonly three: THREE.Plane;
+    /** The components instance to which this plane belongs. */
+    components: Components;
+    /** The world instance to which this plane belongs. */
+    world: World;
+    protected readonly _helper: THREE.Object3D;
+    protected _visible: boolean;
+    protected _enabled: boolean;
+    private _controlsActive;
+    private readonly _arrowBoundBox;
+    private readonly _planeMesh;
+    private readonly _controls;
+    private readonly _hiddenMaterial;
     /**
-     * The size of the secondary grid lines.
+     * Getter for the enabled state of the clipping plane.
+     * @returns {boolean} The current enabled state.
      */
-    size2: number;
+    get enabled(): boolean;
     /**
-     * The distance at which the grid lines start to fade away.
+     * Setter for the enabled state of the clipping plane.
+     * Updates the clipping plane state in the renderer and throws an error if no renderer is found.
+     * @param {boolean} state - The new enabled state.
      */
-    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} */
+    set enabled(state: boolean);
+    /** {@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;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The meshes used for raycasting */
+    get meshes(): THREE.Mesh[];
+    /** The material of the clipping plane representation. */
+    get planeMaterial(): THREE.Material | THREE.Material[];
+    /** The material of the clipping plane representation. */
+    set planeMaterial(material: THREE.Material | THREE.Material[]);
+    /** The size of the clipping plane representation. */
+    get size(): number;
+    /** Sets the size of the clipping plane representation. */
+    set size(size: number);
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Getter for the helper object of the clipping plane.
+     * The helper object is a THREE.Object3D that contains the clipping plane mesh and other related objects.
+     * It is used for positioning, rotating, and scaling the clipping plane in the 3D scene.
+     *
+     * @returns {THREE.Object3D} The helper object of the clipping plane.
      */
-    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 * 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);
+    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
+    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
     /**
-     * The real position of the mouse of the Three.js canvas.
+     * Sets the clipping plane's normal and origin from the given normal and point.
+     * This method resets the clipping plane's state, updates the normal and origin,
+     * and positions the helper object accordingly.
+     *
+     * @param normal - The new normal vector for the clipping plane.
+     * @param point - The new origin point for the clipping plane.
+     *
+     * @returns {void}
      */
-    get position(): THREE.Vector2;
+    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): void;
+    /** {@link Updateable.update} */
+    update: () => void;
     /** {@link Disposable.dispose} */
     dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private setupEvents;
+    private reset;
+    protected toggleControls(state: boolean): void;
+    private newTransformControls;
+    private initializeControls;
+    private createArrowBoundingBox;
+    private changeDrag;
+    private notifyDraggingChanged;
+    private preventCameraMovement;
+    private newHelper;
+    private static newPlaneMesh;
 }
+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";
 /**
@@ -3061,57 +3210,21 @@ export declare class FirstPersonMode implements NavigationMode {
     set(active: boolean): void;
     private setupFirstPersonCamera;
 }
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
 /**
- * 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.
+ * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
  */
-export declare class SimpleRaycaster implements Disposable {
-    /** {@link Component.enabled} */
+export declare class OrbitMode implements NavigationMode {
+    camera: OrthoPerspectiveCamera;
+    /** {@link NavigationMode.enabled} */
     enabled: boolean;
-    /** The components instance to which this Raycaster belongs. */
-    components: Components;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The position of the mouse in the screen. */
-    readonly mouse: Mouse;
-    /**
-     * A reference to the Three.js Raycaster instance.
-     * This is used for raycasting operations.
-     */
-    readonly three: THREE.Raycaster;
-    /**
-     * A reference to the world instance to which this Raycaster belongs.
-     * This is used to access the camera and meshes.
-     */
-    world: World;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Throws a ray from the camera to the mouse or touch event point and returns
-     * the first item found. This also takes into account the clipping planes
-     * used by the renderer.
-     *
-     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
-     * to query. If not provided, it will query all the meshes stored in
-     * {@link Components.meshes}.
-     */
-    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
-    /**
-     * Casts a ray from a given origin in a given direction and returns the first item found.
-     * This method also takes into account the clipping planes used by the renderer.
-     *
-     * @param origin - The origin of the ray.
-     * @param direction - The direction of the ray.
-     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
-     * @returns The first intersection found or 'null' if no intersection was found.
-     */
-    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
-    private intersect;
-    private filterClippingPlanes;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
 }
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
@@ -3133,22 +3246,6 @@ export declare class PlanMode implements NavigationMode {
     /** {@link NavigationMode.set} */
     set(active: boolean): void;
 }
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
- */
-export declare class OrbitMode implements NavigationMode {
-    camera: OrthoPerspectiveCamera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Orbit";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private activateOrbitControls;
-}
 import * as THREE from "three";
 import { CameraProjection } from "./types";
 import { Event } from "../../Types";
@@ -3220,103 +3317,6 @@ export interface NavigationMode {
     /** Whether this navigation mode is active or not. */
     enabled: boolean;
 }
-import * as THREE from "three";
-import { Hideable, Disposable, Event, World } from "../../Types";
-import { Components } from "../../Components";
-/**
- * Each of the clipping planes created by the clipper.
- */
-export declare class SimplePlane implements Disposable, Hideable {
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onDraggingStarted: Event<unknown>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onDraggingEnded: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * The normal vector of the clipping plane.
-     */
-    readonly normal: THREE.Vector3;
-    /**
-     * The origin point of the clipping plane.
-     */
-    readonly origin: THREE.Vector3;
-    /**
-     * The THREE.js Plane object representing the clipping plane.
-     */
-    readonly three: THREE.Plane;
-    /** The components instance to which this plane belongs. */
-    components: Components;
-    /** The world instance to which this plane belongs. */
-    world: World;
-    protected readonly _helper: THREE.Object3D;
-    protected _visible: boolean;
-    protected _enabled: boolean;
-    private _controlsActive;
-    private readonly _arrowBoundBox;
-    private readonly _planeMesh;
-    private readonly _controls;
-    private readonly _hiddenMaterial;
-    /**
-     * Getter for the enabled state of the clipping plane.
-     * @returns {boolean} The current enabled state.
-     */
-    get enabled(): boolean;
-    /**
-     * Setter for the enabled state of the clipping plane.
-     * Updates the clipping plane state in the renderer and throws an error if no renderer is found.
-     * @param {boolean} state - The new enabled state.
-     */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The meshes used for raycasting */
-    get meshes(): THREE.Mesh[];
-    /** The material of the clipping plane representation. */
-    get planeMaterial(): THREE.Material | THREE.Material[];
-    /** The material of the clipping plane representation. */
-    set planeMaterial(material: THREE.Material | THREE.Material[]);
-    /** The size of the clipping plane representation. */
-    get size(): number;
-    /** Sets the size of the clipping plane representation. */
-    set size(size: number);
-    /**
-     * Getter for the helper object of the clipping plane.
-     * The helper object is a THREE.Object3D that contains the clipping plane mesh and other related objects.
-     * It is used for positioning, rotating, and scaling the clipping plane in the 3D scene.
-     *
-     * @returns {THREE.Object3D} The helper object of the clipping plane.
-     */
-    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
-    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
-    /**
-     * Sets the clipping plane's normal and origin from the given normal and point.
-     * This method resets the clipping plane's state, updates the normal and origin,
-     * and positions the helper object accordingly.
-     *
-     * @param normal - The new normal vector for the clipping plane.
-     * @param point - The new origin point for the clipping plane.
-     *
-     * @returns {void}
-     */
-    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): void;
-    /** {@link Updateable.update} */
-    update: () => void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private reset;
-    protected toggleControls(state: boolean): void;
-    private newTransformControls;
-    private initializeControls;
-    private createArrowBoundingBox;
-    private changeDrag;
-    private notifyDraggingChanged;
-    private preventCameraMovement;
-    private newHelper;
-    private static newPlaneMesh;
-}
 import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
  * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
@@ -3343,6 +3343,11 @@ 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>;
+}
 import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
  * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
@@ -3360,11 +3365,6 @@ export declare class IfcStreamingSettings extends IfcFragmentSettings {
     minAssetsSize: number;
 }
 import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-}
-import * as WEBIFC from "web-ifc";
 import * as THREE from "three";
 export declare class Units {
     factor: number;
@@ -3403,11 +3403,6 @@ export interface StreamedAsset {
         color: number[];
     }[];
 }
-import { BufferGeometry } from "three";
-import * as THREE from "three";
-export declare class TransformHelper {
-    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
-}
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
     [modelID: string]: RelationsMap;
@@ -3432,5 +3427,10 @@ export type InverseAttributes = [
     "ContainsElements"
 ];
 export type InverseAttribute = InverseAttributes[number];
+import { BufferGeometry } from "three";
+import * as THREE from "three";
+export declare class TransformHelper {
+    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
+}
 }